andyjeffries-rubyrep 1.2.1

data/spec/proxy_cursor_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ProxyCursor do
+  before(:each) do
+    Initializer.configuration = proxied_config
+  end
+
+  it "initialize should store session and table and cache the primary keys of table" do
+    connection = create_mock_proxy_connection 'dummy_table', ['dummy_key']
+    
+    cursor = ProxyCursor.new connection, 'dummy_table'
+    
+    cursor.connection.should == connection
+    cursor.table.should == 'dummy_table'
+    cursor.primary_key_names.should == ['dummy_key']
+  end
+  
+  it "prepare_fetch should initiate the query and wrap it for type casting" do
+    connection = ProxyConnection.new Initializer.configuration.left
+    
+    cursor = ProxyCursor.new(connection, 'scanner_records')
+    cursor.prepare_fetch
+    cursor.cursor.should be_an_instance_of(TypeCastingCursor)
+    cursor.cursor.next_row.should == {'id' => 1, 'name' => 'Alice - exists in both databases'}
+  end
+  
+  it "prepare_fetch called with option :row_keys should initiate the correct query" do
+    # Note: I am testing row_keys exclusively to make sure that this type of 
+    #       sub query will work correctly on all supported databases
+    connection = ProxyConnection.new Initializer.configuration.left
+    
+    cursor = ProxyCursor.new(connection, 'extender_combined_key')
+    cursor.prepare_fetch :row_keys => [
+      {'first_id' => 1, 'second_id' => 1}, 
+      {'first_id' => 1, 'second_id' => 2}
+    ]
+    cursor.cursor.next_row.should == {'first_id' => 1, 'second_id' => 1, 'name' => 'aa'}
+    cursor.cursor.next_row.should == {'first_id' => 1, 'second_id' => 2, 'name' => 'ab'}
+    cursor.cursor.next?.should == false
+  end
+
+  
+  it "destroy should clear and nil the cursor" do
+    connection = create_mock_proxy_connection 'dummy_table', ['dummy_key']
+    cursor = ProxyCursor.new connection, 'dummy_table'
+    
+    table_cursor = mock("DBCursor")
+    table_cursor.should_receive(:clear)
+    cursor.cursor = table_cursor
+    
+    cursor.destroy  
+    cursor.cursor.should be_nil
+  end  
+end

data/spec/proxy_row_cursor_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ProxyRowCursor do
+  before(:each) do
+    Initializer.configuration = standard_config
+  end
+
+  it "initialize should super to ProxyCursor" do
+    session = create_mock_proxy_connection 'dummy_table', ['dummy_id']
+    cursor = ProxyRowCursor.new session, 'dummy_table'
+    cursor.table.should == 'dummy_table'        
+  end
+  
+  it "next? should delegate to the DB cursor" do
+    session = create_mock_proxy_connection 'dummy_table', ['dummy_id']
+    cursor = ProxyRowCursor.new session, 'dummy_table'
+    
+    table_cursor = mock("DBCursor")
+    table_cursor.should_receive(:next?).and_return(true)
+    cursor.cursor = table_cursor
+    
+    cursor.next?.should == true
+  end
+  
+  it "next_row should return the next row in the cursor" do
+    session = create_mock_proxy_connection 'dummy_table', ['dummy_id']
+    cursor = ProxyRowCursor.new session, 'dummy_table'
+    
+    table_cursor = mock("DBCursor")
+    table_cursor.should_receive(:next_row).and_return(:dummy_row)
+    cursor.cursor = table_cursor
+    
+    cursor.next_row.should == :dummy_row  
+  end
+  
+  it "next_row_keys_and_checksum should store the found row under current_row" do
+    session = create_mock_proxy_connection 'dummy_table', ['dummy_id']
+    cursor = ProxyRowCursor.new session, 'dummy_table'
+    
+    table_cursor = mock("DBCursor")
+    table_cursor.should_receive(:next_row).and_return('dummy_id' => 'dummy_value')
+    
+    cursor.cursor = table_cursor
+    cursor.next_row_keys_and_checksum
+    cursor.current_row.should == {'dummy_id' => 'dummy_value'}
+  end
+
+  it "next_row_keys_and_checksum should returns the primary_keys and checksum of the found row" do
+    session = ProxyConnection.new proxied_config.left
+
+    cursor = ProxyRowCursor.new session, 'scanner_records'
+    cursor.prepare_fetch
+    
+    keys, checksum = cursor.next_row_keys_and_checksum
+ 
+    expected_checksum = Digest::SHA1.hexdigest( 
+      Marshal.dump('id' => 1, 'name' => 'Alice - exists in both databases')
+    )
+    
+    keys.should == {'id' => 1}
+    checksum.should == expected_checksum
+  end
+  
+end

data/spec/proxy_runner_spec.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ProxyRunner do
+  before(:each) do
+    DRb.stub!(:start_service)
+    DRb.thread.stub!(:join)
+    $stderr.stub!(:puts)
+  end
+
+  it "get_options should return options as nil and status as 1 if command line parameters are unknown" do
+    # also verify that an error message is printed
+    $stderr.should_receive(:puts).any_number_of_times
+    options, status = ProxyRunner.new.get_options ["--nonsense"]
+    options.should == nil
+    status.should == 1
+  end
+  
+  it "get_options should return options as nil and status as 0 if command line includes '--help'" do
+    # also verify that the help message is printed
+    $stderr.should_receive(:puts)
+    options, status = ProxyRunner.new.get_options ["--help"]
+    options.should == nil
+    status.should == 0
+  end
+  
+  it "get_options should return the default options if none were given on the command line" do
+    options, status = ProxyRunner.new.get_options []
+    options.should == ProxyRunner::DEFAULT_OPTIONS
+    status.should == 0
+  end
+  
+  it "get_options should return :host and :port options as per given command line" do
+    options, status = ProxyRunner.new.get_options ["--host", "127.0.0.1", "--port", "1234"]
+    options.should == {:host => '127.0.0.1', :port => 1234}
+    status.should == 0
+  end
+
+  it "construct_url should create the correct druby URL" do
+    ProxyRunner.new.build_url(:host => '127.0.0.1', :port => '1234').should == "druby://127.0.0.1:1234"
+  end
+  
+  it "start_server should create a DatabaseProxy and start the DRB server" do
+    DatabaseProxy.should_receive(:new)
+    DRb.should_receive(:start_service,"druby://127.0.0.1:1234")
+    DRb.stub!(:thread).and_return(Object.new)
+    DRb.thread.should_receive(:join)
+    ProxyRunner.new.start_server("druby://127.0.0.1:1234")
+  end
+  
+  it "run should not start a server if the command line is invalid" do
+    DRb.should_not_receive(:start_service)
+    DRb.stub!(:thread).and_return(Object.new)
+    DRb.thread.should_not_receive(:join)
+    ProxyRunner.run("--nonsense")    
+  end
+  
+  it "run should start a server if the command line is correct" do
+    DRb.should_receive(:start_service)
+    DRb.stub!(:thread).and_return(Object.new)
+    DRb.thread.should_receive(:join)
+    ProxyRunner.run(["--port=1234"])    
+  end
+  
+  it "should register itself with CommandRunner" do
+    CommandRunner.commands['proxy'][:command].should == ProxyRunner
+    CommandRunner.commands['proxy'][:description].should be_an_instance_of(String)
+  end
+end

data/spec/replication_difference_spec.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ReplicationDifference do
+  before(:each) do
+    Initializer.configuration = standard_config
+  end
+
+  it "initialize should store the loaders" do
+    session = Session.new
+    loaders = LoggedChangeLoaders.new session
+    diff = ReplicationDifference.new loaders
+    diff.loaders.should == loaders
+  end
+
+  it "loaded? should return true if a difference was loaded" do
+    diff = ReplicationDifference.new LoggedChangeLoaders.new(Session.new)
+    diff.should_not be_loaded
+    diff.loaded = true
+    diff.should be_loaded
+  end
+
+  it "load should leave the instance unloaded if no changes are available" do
+    diff = ReplicationDifference.new LoggedChangeLoaders.new(Session.new)
+    diff.load
+    diff.should_not be_loaded
+  end
+
+  it "load should load left differences successfully" do
+    session = Session.new
+    session.left.begin_db_transaction
+    begin
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'scanner_records',
+        'change_key' => 'id|1',
+        'change_type' => 'I',
+        'change_time' => Time.now
+      }
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      diff.should be_loaded
+      diff.type.should == :left
+      diff.changes[:left].key.should == {'id' => '1'}
+    ensure
+      session.left.rollback_db_transaction
+    end
+  end
+
+  it "load should load right differences successfully" do
+    session = Session.new
+    session.right.begin_db_transaction
+    begin
+      session.right.insert_record 'rr_pending_changes', {
+        'change_table' => 'scanner_records',
+        'change_key' => 'id|1',
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      diff.should be_loaded
+      diff.type.should == :right
+      diff.changes[:right].key.should == {'id' => '1'}
+    ensure
+      session.right.rollback_db_transaction
+    end
+  end
+
+  it "load should load conflict differences successfully" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "table_with_manual_key, extender_without_key"
+
+    session = Session.new config
+    session.left.begin_db_transaction
+    session.right.begin_db_transaction
+    begin
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'dummy_table',
+        'change_key' => 'id|2',
+        'change_type' => 'I',
+        'change_time' => Time.now
+      }
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'table_with_manual_key',
+        'change_key' => 'id|1',
+        'change_new_key' => 'id|1',
+        'change_type' => 'U',
+        'change_time' => 5.seconds.from_now
+      }
+      session.right.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_without_key',
+        'change_key' => 'id|1',
+        'change_type' => 'D',
+        'change_time' => 5.seconds.ago
+      }
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      diff.should be_loaded
+      diff.type.should == :conflict
+      diff.changes[:left].type.should == :update
+      diff.changes[:left].table.should == 'table_with_manual_key'
+      diff.changes[:left].key.should == {'id' => '1'}
+      diff.changes[:right].type.should == :delete
+      diff.changes[:right].table.should == 'extender_without_key'
+      diff.changes[:right].key.should == {'id' => '1'}
+    ensure
+      session.left.rollback_db_transaction
+      session.right.rollback_db_transaction
+    end
+  end
+
+  it "amend should amend the replication difference with new found changes" do
+    session = Session.new
+    session.left.begin_db_transaction
+    session.right.begin_db_transaction
+    begin
+      session.right.insert_record 'rr_pending_changes', {
+        'change_table' => 'scanner_records',
+        'change_key' => 'id|1',
+        'change_type' => 'I',
+        'change_time' => Time.now
+      }
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      diff.should be_loaded
+      diff.type.should == :right
+      diff.changes[:right].key.should == {'id' => '1'}
+
+      # if there are no changes, the diff should still be the same
+      diff.amend
+      diff.type.should == :right
+      diff.changes[:right].key.should == {'id' => '1'}
+
+      # should recognize new changes
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'scanner_records',
+        'change_key' => 'id|1',
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+      diff.amend
+      diff.type.should == :conflict
+      diff.changes[:left].key.should == {'id' => '1'}
+      diff.changes[:right].key.should == {'id' => '1'}
+    ensure
+      session.right.rollback_db_transaction
+      session.left.rollback_db_transaction
+    end
+  end
+
+  it "to_yaml should blank out session" do
+    diff = ReplicationDifference.new :dummy_session
+    diff.to_yaml.should_not =~ /session/
+  end
+end

data/spec/replication_extender_interface_spec.rb

@@ -0,0 +1,367 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'yaml'
+
+include RR
+
+# All ReplicationExtenders need to pass this spec
+describe "ReplicationExtender", :shared => true do
+  before(:each) do
+  end
+
+  it "create_replication_trigger created triggers should log data changes" do
+    session = nil
+    begin
+      session = Session.new
+      session.left.begin_db_transaction
+      params = {
+        :trigger_name => 'rr_trigger_test',
+        :table => 'trigger_test',
+        :keys => ['first_id', 'second_id'],
+        :log_table => 'rr_pending_changes',
+        :key_sep => '|',
+        :exclude_rr_activity => false,
+      }
+      session.left.create_replication_trigger params
+
+      change_start = Time.now
+
+      session.left.insert_record 'trigger_test', {
+        'first_id' => 1,
+        'second_id' => 2,
+        'name' => 'bla'
+      }
+      session.left.execute "update trigger_test set second_id = 9 where first_id = 1 and second_id = 2"
+      session.left.delete_record 'trigger_test', {
+        'first_id' => 1,
+        'second_id' => 9,
+      }
+
+      rows = session.left.connection.select_all("select * from rr_pending_changes order by id")
+
+      # Verify that the timestamps are created correctly
+      rows.each do |row|
+        Time.parse(row['change_time']).to_i >= change_start.to_i
+        Time.parse(row['change_time']).to_i <= Time.now.to_i
+      end
+
+      rows.each {|row| row.delete 'id'; row.delete 'change_time'}
+      rows.should == [
+        {'change_table' => 'trigger_test', 'change_key' => 'first_id|1|second_id|2', 'change_new_key' => nil, 'change_type' => 'I'},
+        {'change_table' => 'trigger_test', 'change_key' => 'first_id|1|second_id|2', 'change_new_key' => 'first_id|1|second_id|9', 'change_type' => 'U'},
+        {'change_table' => 'trigger_test', 'change_key' => 'first_id|1|second_id|9', 'change_new_key' => nil, 'change_type' => 'D'},
+      ]
+    ensure
+      session.left.execute 'delete from trigger_test' if session
+      session.left.execute 'delete from rr_pending_changes' if session
+      session.left.rollback_db_transaction if session
+    end
+  end
+
+  it "created triggers should not log rubyrep initiated changes if :exclude_rubyrep_activity is true" do
+    session = nil
+    begin
+      session = Session.new
+      session.left.begin_db_transaction
+      params = {
+        :trigger_name => 'rr_trigger_test',
+        :table => 'trigger_test',
+        :keys => ['first_id', 'second_id'],
+        :log_table => 'rr_pending_changes',
+        :key_sep => '|',
+        :exclude_rr_activity => true,
+        :activity_table => "rr_running_flags",
+      }
+      session.left.create_replication_trigger params
+
+      session.left.insert_record 'rr_running_flags', {
+        'active' => 1
+      }
+      session.left.insert_record 'trigger_test', {
+        'first_id' => 1,
+        'second_id' => 2,
+        'name' => 'bla'
+      }
+      session.left.connection.execute('delete from rr_running_flags')
+      session.left.insert_record 'trigger_test', {
+        'first_id' => 1,
+        'second_id' => 3,
+        'name' => 'bla'
+      }
+
+      rows = session.left.connection.select_all("select * from rr_pending_changes order by id")
+      rows.each {|row| row.delete 'id'; row.delete 'change_time'}
+      rows.should == [{
+          'change_table' => 'trigger_test',
+          'change_key' => 'first_id|1|second_id|3',
+          'change_new_key' => nil,
+          'change_type' => 'I'
+        }]
+    ensure
+      session.left.execute 'delete from trigger_test' if session
+      session.left.execute 'delete from rr_pending_changes' if session
+      session.left.rollback_db_transaction if session
+    end
+  end
+
+  it "created triggers should work with tables having non-combined primary keys" do
+    session = nil
+    begin
+      session = Session.new
+      session.left.begin_db_transaction
+      params = {
+        :trigger_name => 'rr_extender_no_record',
+        :table => 'extender_no_record',
+        :keys => ['id'],
+        :log_table => 'rr_pending_changes',
+        :key_sep => '|',
+      }
+      session.left.create_replication_trigger params
+      session.left.insert_record 'extender_no_record', {
+        'id' => 9,
+        'name' => 'bla'
+      }
+      rows = session.left.connection.select_all("select * from rr_pending_changes order by id")
+      rows.each {|row| row.delete 'id'; row.delete 'change_time'}
+      rows.should == [{
+          'change_table' => 'extender_no_record',
+          'change_key' => 'id|9',
+          'change_new_key' => nil,
+          'change_type' => 'I'
+        }]
+    ensure
+      if session
+        session.left.execute 'delete from extender_no_record'
+        session.left.execute 'delete from rr_pending_changes'
+        session.left.drop_replication_trigger('rr_extender_no_record', 'extender_no_record')
+        session.left.rollback_db_transaction
+      end
+    end
+  end
+
+  it "created triggers should work with primary keys holding multi-byte text values" do
+    session = nil
+    begin
+      session = Session.new
+      session.left.begin_db_transaction
+      params = {
+        :trigger_name => 'rr_scanner_text_key',
+        :table => 'scanner_text_key',
+        :keys => ['text_id'],
+        :log_table => 'rr_pending_changes',
+        :key_sep => '|',
+      }
+      session.left.create_replication_trigger params
+      session.left.insert_record 'scanner_text_key', {
+        'text_id' => 'よろしくお願(ねが)いします yoroshiku onegai shimasu: I humbly ask for your favor.',
+        'name' => 'bla'
+      }
+      rows = session.left.connection.select_all("select * from rr_pending_changes order by id")
+      rows.each {|row| row.delete 'id'; row.delete 'change_time'}
+      rows.should == [{
+          'change_table' => 'scanner_text_key',
+          'change_key' => 'text_id|よろしくお願(ねが)いします yoroshiku onegai shimasu: I humbly ask for your favor.',
+          'change_new_key' => nil,
+          'change_type' => 'I'
+        }]
+      found_key = rows[0]['change_key'].sub(/^text_id\|/, '')
+      session.left.
+        select_one("select * from scanner_text_key where text_id = '#{found_key}'").
+        should_not be_nil
+    ensure
+      if session
+        session.left.execute "delete from scanner_text_key where text_id = 'よろしくお願(ねが)いします yoroshiku onegai shimasu: I humbly ask for your favor.'"
+        session.left.execute 'delete from rr_pending_changes'
+        session.left.drop_replication_trigger('rr_scanner_text_key', 'scanner_text_key')
+        session.left.rollback_db_transaction
+      end
+    end
+  end
+
+  it "replication_trigger_exists? and drop_replication_trigger should work correctly" do
+    session = nil
+    begin
+      session = Session.new
+      if session.left.replication_trigger_exists?('rr_trigger_test', 'trigger_test')
+        session.left.drop_replication_trigger('rr_trigger_test', 'trigger_test')
+      end
+      session.left.begin_db_transaction
+      params = {
+        :trigger_name => 'rr_trigger_test',
+        :table => 'trigger_test',
+        :keys => ['first_id'],
+        :log_table => 'rr_pending_changes',
+        :key_sep => '|',
+      }
+      session.left.create_replication_trigger params
+
+      session.left.replication_trigger_exists?('rr_trigger_test', 'trigger_test').
+        should be_true
+      session.left.drop_replication_trigger('rr_trigger_test', 'trigger_test')
+      session.left.replication_trigger_exists?('rr_trigger_test', 'trigger_test').
+        should be_false
+    ensure
+      session.left.rollback_db_transaction if session
+    end
+  end
+
+  it "sequence_values should return an empty hash if table has no sequences" do
+    session = Session.new
+    session.left.sequence_values('rr', 'scanner_text_key').
+      should == {}
+  end
+
+  it "sequence_values should return the correct sequence settings" do
+    session = nil
+    begin
+      session = Session.new
+      session.left.begin_db_transaction
+      session.left.execute 'delete from sequence_test'
+      left_sequence_values = session.left.sequence_values 'rr', 'sequence_test'
+      right_sequence_values = session.right.sequence_values 'rr', 'sequence_test'
+      session.left.update_sequences \
+        'rr', 'sequence_test', 5, 2,
+        left_sequence_values, right_sequence_values, 5
+      sequence_value = session.left.sequence_values('rr', 'sequence_test').values[0]
+      sequence_value[:increment].should == 5
+      (sequence_value[:value] % 5).should == 2
+    ensure
+      session.left.clear_sequence_setup 'rr', 'sequence_test' if session
+      session.left.execute "delete from sequence_test" if session
+      session.left.rollback_db_transaction if session
+    end
+  end
+
+  it "update_sequences should ensure that a table's auto generated ID values have the correct increment and offset" do
+    session = nil
+    begin
+      session = Session.new
+      session.left.begin_db_transaction
+
+      # Note:
+      # Calling ensure_sequence_setup twice with different values to ensure that
+      # it is actually does something.
+
+      session.left.execute 'delete from sequence_test'
+      left_sequence_values = session.left.sequence_values 'rr', 'sequence_test'
+      right_sequence_values = session.right.sequence_values 'rr', 'sequence_test'
+      session.left.update_sequences \
+        'rr', 'sequence_test', 1, 0,
+        left_sequence_values, right_sequence_values, 5
+      id1, id2 = get_example_sequence_values(session)
+      (id2 - id1).should == 1
+
+      left_sequence_values = session.left.sequence_values 'rr', 'sequence_test'
+      right_sequence_values = session.right.sequence_values 'rr', 'sequence_test'
+      session.left.update_sequences \
+        'rr', 'sequence_test', 5, 2,
+        left_sequence_values, right_sequence_values, 5
+      id1, id2 = get_example_sequence_values(session)
+      (id2 - id1).should == 5
+      (id1 % 5).should == 2
+    ensure
+      session.left.clear_sequence_setup 'rr', 'sequence_test' if session
+      session.left.execute "delete from sequence_test" if session
+      session.left.rollback_db_transaction if session
+    end
+  end
+
+  it "update_sequences shoud set the sequence up correctly if the table is not empty" do
+    session = nil
+    begin
+      session = Session.new
+      session.left.begin_db_transaction
+      session.left.execute 'delete from sequence_test'
+      session.left.insert_record 'sequence_test', { 'name' => 'whatever' }
+      left_sequence_values = session.left.sequence_values 'rr', 'sequence_test'
+      right_sequence_values = session.right.sequence_values 'rr', 'sequence_test'
+      session.left.update_sequences \
+        'rr', 'sequence_test', 2, 0,
+        left_sequence_values, right_sequence_values, 5
+      id1, id2 = get_example_sequence_values(session)
+      (id2 - id1).should == 2
+    ensure
+      session.left.clear_sequence_setup 'rr', 'sequence_test' if session
+      session.left.execute "delete from sequence_test" if session
+      session.left.rollback_db_transaction if session
+    end
+  end
+
+  it "update_sequences shoud set the sequence up correctly if the other table is already set up correctly" do
+    session = nil
+    begin
+      session = Session.new
+      session.left.begin_db_transaction
+      session.right.begin_db_transaction
+      session.left.execute 'delete from sequence_test'
+      session.left.insert_record 'sequence_test', { 'name' => 'whatever' }
+      left_sequence_values = session.left.sequence_values 'rr', 'sequence_test'
+      right_sequence_values = session.right.sequence_values 'rr', 'sequence_test'
+
+      # setup right table sequence
+      left_sequence_values = session.left.sequence_values 'rr', 'sequence_test'
+      right_sequence_values = session.right.sequence_values 'rr', 'sequence_test'
+      session.right.update_sequences \
+        'rr', 'sequence_test', 2, 1,
+        left_sequence_values, right_sequence_values, 5
+
+      # now setup left table sequence and verify result
+      left_sequence_values = session.left.sequence_values 'rr', 'sequence_test'
+      right_sequence_values = session.right.sequence_values 'rr', 'sequence_test'
+      session.left.update_sequences \
+        'rr', 'sequence_test', 2, 0,
+        left_sequence_values, right_sequence_values, 5
+      id1, id2 = get_example_sequence_values(session)
+      (id2 - id1).should == 2
+    ensure
+      session.left.clear_sequence_setup 'rr', 'sequence_test' if session
+      session.right.clear_sequence_setup 'rr', 'sequence_test' if session
+      session.left.execute "delete from sequence_test" if session
+      session.left.rollback_db_transaction if session
+      session.right.rollback_db_transaction if session
+    end
+  end
+
+  it "clear_sequence_setup should remove custom sequence settings" do
+    session = nil
+    begin
+      session = Session.new
+      session.left.begin_db_transaction
+      left_sequence_values = session.left.sequence_values 'rr', 'sequence_test'
+      right_sequence_values = session.right.sequence_values 'rr', 'sequence_test'
+      session.left.update_sequences \
+        'rr', 'sequence_test', 2, 0,
+        left_sequence_values, right_sequence_values, 5
+      session.left.clear_sequence_setup 'rr', 'sequence_test'
+      id1, id2 = get_example_sequence_values(session)
+      (id2 - id1).should == 1
+    ensure
+      session.left.clear_sequence_setup 'rr', 'sequence_test' if session
+      session.left.execute "delete from sequence_test" if session
+      session.left.rollback_db_transaction if session
+    end
+  end
+
+  it "add_big_primary_key should add a 8 byte, auto incrementing primary key" do
+    session = nil
+    begin
+      session = Session.new
+      initializer = ReplicationInitializer.new(session)
+      initializer.silence_ddl_notices(:left) do
+        session.left.drop_table 'big_key_test' if session.left.tables.include? 'big_key_test'
+        session.left.create_table 'big_key_test'.to_sym
+        session.left.add_column 'big_key_test', :name, :string
+        session.left.remove_column 'big_key_test', 'id'
+        session.left.add_big_primary_key 'big_key_test', 'id'
+      end
+      # should auto generate the primary key if not manually specified
+      session.left.insert_record 'big_key_test', {'name' => 'bla'}
+      session.left.select_one("select id from big_key_test where name = 'bla'")['id'].
+        to_i.should > 0
+
+      # should allow 8 byte values
+      session.left.insert_record 'big_key_test', {'id' => 1e18.to_i, 'name' => 'blub'}
+      session.left.select_one("select id from big_key_test where name = 'blub'")['id'].
+        to_i.should == 1e18.to_i
+    end
+  end
+end