rubyrep 1.2.0 → 2.0.0

data/spec/postgresql_schema_support_spec.rb

@@ -1,212 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-require File.dirname(__FILE__) + "/../config/test_config.rb"
-
-describe "PostgreSQL schema support" do
-  before(:each) do
-    config = deep_copy(standard_config)
-    config.options[:rep_prefix] = 'rx'
-    config.left[:schema_search_path] = 'rr'
-    config.right[:schema_search_path] = 'rr'
-    Initializer.configuration = config
-  end
-
-  after(:each) do
-  end
-
-  if Initializer.configuration.left[:adapter] == 'postgresql'
-    it "tables should show the tables from the schema and no others" do
-      session = Session.new
-      session.left.tables.include?('rr_simple').should be_true
-      session.left.tables.include?('scanner_records').should be_false
-    end
-
-    it "tables should not show the tables from other schemas" do
-      session = Session.new standard_config
-      session.left.tables.include?('scanner_records').should be_true
-      session.left.tables.include?('rr_simple').should be_false
-    end
-
-    it "primary_key_names should work" do
-      session = Session.new
-      session.left.primary_key_names('rr_simple').should == ['id']
-    end
-
-    it "primary_key_names should pick the table in the target schema" do
-      session = Session.new
-      session.left.primary_key_names('rr_duplicate').should == ['id']
-    end
-
-    it "column_names should work" do
-      session = Session.new
-      session.left.column_names('rr_simple').should == ['id', 'name']
-    end
-
-    it "column_names should pick the table in the target schema" do
-      session = Session.new
-      session.left.column_names('rr_duplicate').should == ['id', 'name']
-    end
-
-    it "referenced_tables should work" do
-      session = Session.new
-      session.left.referenced_tables(['rr_referencing']).should == {
-        'rr_referencing' => ['rr_referenced']
-      }
-    end
-
-    it "table_select_query should work" do
-      session = Session.new
-      session.left.table_select_query('rr_simple').
-        should == 'select "id", "name" from "rr_simple" order by "id"'
-    end
-
-    it "TypeCastingCursor should work" do
-      session = Session.new
-      org_cursor = session.left.select_cursor(
-        :query => "select id, name from rr_simple where id = 1",
-        :type_cast => false
-      )
-      cursor = TypeCastingCursor.new session.left, 'rr_simple', org_cursor
-
-      row = cursor.next_row
-
-      row.should == {
-        'id' => 1,
-        'name' => 'bla'
-      }
-    end
-
-    it "sequence_values should pick the table in the target schema" do
-      session = Session.new
-      session.left.sequence_values('rx', 'rr_duplicate').keys.should == ["rr_duplicate_id_seq"]
-    end
-
-    it "clear_sequence_setup should pick the table in the target schema" do
-      session = nil
-      begin
-        session = Session.new
-        initializer = ReplicationInitializer.new(session)
-        session.left.begin_db_transaction
-        session.right.begin_db_transaction
-        table_pair = {:left => 'rr_duplicate', :right => 'rr_duplicate'}
-        initializer.ensure_sequence_setup table_pair, 5, 2, 1
-        id1, id2 = get_example_sequence_values(session, 'rr_duplicate')
-        (id2 - id1).should == 5
-        (id1 % 5).should == 2
-
-        initializer.clear_sequence_setup :left, 'rr_duplicate'
-        id1, id2 = get_example_sequence_values(session, 'rr_duplicate')
-        (id2 - id1).should == 1
-      ensure
-        [:left, :right].each do |database|
-          initializer.clear_sequence_setup database, 'rr_duplicate' rescue nil if session
-          session.send(database).execute "delete from rr_duplicate" rescue nil if session
-          session.send(database).rollback_db_transaction rescue nil if session
-        end
-      end
-
-    end
-
-    it "sequence setup should work" do
-      session = nil
-      begin
-        session = Session.new
-        initializer = ReplicationInitializer.new(session)
-        session.left.begin_db_transaction
-        session.right.begin_db_transaction
-        table_pair = {:left => 'rr_sequence_test', :right => 'rr_sequence_test'}
-        initializer.ensure_sequence_setup table_pair, 5, 2, 1
-        id1, id2 = get_example_sequence_values(session, 'rr_sequence_test')
-        (id2 - id1).should == 5
-        (id1 % 5).should == 2
-      ensure
-        [:left, :right].each do |database|
-          initializer.clear_sequence_setup database, 'rr_sequence_test' rescue nil if session
-          session.send(database).execute "delete from rr_sequence_test" rescue nil if session
-          session.send(database).rollback_db_transaction rescue nil if session
-        end
-      end
-    end
-
-    it "clear_sequence_setup should work" do
-      session = nil
-      begin
-        session = Session.new
-        initializer = ReplicationInitializer.new(session)
-        session.left.begin_db_transaction
-        session.right.begin_db_transaction
-        table_pair = {:left => 'rr_sequence_test', :right => 'rr_sequence_test'}
-        initializer.ensure_sequence_setup table_pair, 5, 2, 2
-        initializer.clear_sequence_setup :left, 'rr_sequence_test'
-        id1, id2 = get_example_sequence_values(session, 'rr_sequence_test')
-        (id2 - id1).should == 1
-      ensure
-        [:left, :right].each do |database|
-          initializer.clear_sequence_setup database, 'rr_sequence_test' if session
-          session.send(database).execute "delete from rr_sequence_test" if session
-          session.send(database).rollback_db_transaction if session
-        end
-      end
-    end
-
-    it "initializer should create tables in target schema" do
-      session = nil
-      begin
-        config = deep_copy(Initializer.configuration)
-        config.options[:rep_prefix] = 'ry'
-        session = Session.new config
-        session.left.begin_db_transaction
-
-        initializer = ReplicationInitializer.new(session)
-        initializer.create_change_log(:left)
-
-        # no exception ==> means table was created in target schema
-        session.left.select_one("select id from rr.ry_pending_changes")
-      ensure
-        session.left.rollback_db_transaction if session
-      end
-    end
-
-    it "create_trigger, trigger_exists? and drop_trigger should work" do
-      session = nil
-      begin
-        session = Session.new
-        initializer = ReplicationInitializer.new(session)
-        session.left.begin_db_transaction
-
-        initializer.create_trigger :left, 'rr_trigger_test'
-        initializer.trigger_exists?(:left, 'rr_trigger_test').
-          should be_true
-
-        # Verify that the trigger can find the pending_changes table even if
-        # current search_path does not include it.
-        session.left.execute "set search_path = 'public'"
-        session.left.execute <<-EOF
-          insert into rr.rr_trigger_test(first_id, second_id) values(10, 11)
-        EOF
-        session.left.execute "set search_path = 'rr'"
-        session.left.select_one("select change_key from rx_pending_changes")['change_key'].
-          should == "first_id|10|second_id|11"
-
-        initializer.drop_trigger(:left, 'rr_trigger_test')
-        initializer.trigger_exists?(:left, 'rr_trigger_test').
-          should be_false
-      ensure
-        session.left.rollback_db_transaction if session
-      end
-    end
-
-    it "should work with complex search paths" do
-      config = deep_copy(standard_config)
-      config.left[:schema_search_path] = 'public,rr'
-      config.right[:schema_search_path] = 'public,rr'
-      session = Session.new(config)
-
-      tables = session.left.tables
-      tables.include?('rr_simple').should be_true
-      tables.include?('scanner_records').should be_true
-    end
-  end
-end

data/spec/postgresql_support_spec.rb

@@ -1,63 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-require File.dirname(__FILE__) + "/../config/test_config.rb"
-
-describe "PostgreSQL support" do
-  before(:each) do
-    Initializer.configuration = standard_config
-  end
-
-  after(:each) do
-  end
-
-  if Initializer.configuration.left[:adapter] == 'postgresql'
-
-    it "should read & write microsecond times" do
-      session = nil
-      begin
-        session = Session.new
-        session.left.begin_db_transaction
-        session.left.insert_record('extender_type_check',
-          {'id' => 2, 'timestamp' => Time.local(2009, "feb", 16, 20, 48, 1, 543)}
-        )
-
-        org_cursor = session.left.select_cursor(
-          :query => "select id, timestamp from extender_type_check where id = 2",
-          :type_cast => false
-        )
-        cursor = TypeCastingCursor.new session.left, 'extender_type_check', org_cursor
-
-        row = cursor.next_row
-        row['timestamp'].usec.should == 543
-        cursor.clear
-      ensure
-        session.left.rollback_db_transaction if session
-      end
-    end
-
-    it "should not round microsecond times to incorrect value" do
-      session = nil
-      begin
-        session = Session.new
-        session.left.begin_db_transaction
-        session.left.insert_record('extender_type_check',
-          {'id' => 2, 'timestamp' => Time.local(2009, "feb", 16, 13, 37, 11, 126291)}
-        )
-
-        org_cursor = session.left.select_cursor(
-          :query => "select id, timestamp from extender_type_check where id = 2",
-          :type_cast => false
-        )
-        cursor = TypeCastingCursor.new session.left, 'extender_type_check', org_cursor
-
-        row = cursor.next_row
-        row['timestamp'].usec.should == 126291
-        cursor.clear
-      ensure
-        session.left.rollback_db_transaction if session
-      end
-    end
-  end
-end

data/spec/progress_bar_spec.rb

@@ -1,77 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-include ScanProgressPrinters
-
-describe ProgressBar do
-  before(:each) do
-    @org_stdout = $stdout
-    $stdout = StringIO.new
-    @old_arg = ProgressBar.arg
-  end
-
-  after(:each) do
-    ProgressBar.arg = @old_arg
-    $stdout = @org_stdout
-  end
-
-  it "arg should store the command line argument and max_markers return the correct marker number" do
-    ProgressBar.arg = nil
-    ProgressBar.new(100, Session.new(standard_config), 'bla', 'blub').max_markers.should == ProgressBar::MAX_MARKERS
-    ProgressBar.arg = "2"
-    ProgressBar.new(100, Session.new(standard_config), 'bla', 'blub').max_markers.should == 2
-  end
-
-  it "step should use ANSI codes if options :use_ansi is set" do
-    session = Session.new(deep_copy(standard_config))
-    session.configuration.options[:use_ansi] = true
-    bar = ProgressBar.new(10, session, 'bla', 'blub')
-    bar.step 1
-    bar.step 1
-    $stdout.string.should =~ Regexp.new(Regexp.escape("\e[1"))
-  end
-
-  it "step should not use ANSI codes if options :use_ansi is not true" do
-    session = Session.new(deep_copy(standard_config))
-    session.configuration.options[:use_ansi] = false
-    bar = ProgressBar.new(10, session, 'bla', 'blub')
-    bar.step 1
-    bar.step 1
-    $stdout.string.should_not =~ Regexp.new(Regexp.escape("\e[1"))
-  end
-
-  it "should register itself with ScanRunner" do
-    RR::ScanProgressPrinters.printers[:progress_bar][:printer_class].
-      should == ProgressBar
-  end
-
-  it "step should print the correct progress" do
-    bar = ProgressBar.new(1000, Session.new(standard_config), 'bla', 'blub')
-    bar.step 200
-    bar.step 300
-    $stdout.string.count('.').should == ProgressBar::MAX_MARKERS / 2
-    bar.step 500
-    $stdout.string.count('.').should == ProgressBar::MAX_MARKERS
-  end
-
-  it "step should work around weird floating point rounding issues" do
-    bar = ProgressBar.new(56, Session.new(standard_config), 'bla', 'blub')
-    (1..56).each {bar.step 1}
-    $stdout.string.count('.').should == ProgressBar::MAX_MARKERS
-  end
-
-  it "if max_steps is 0, any step call should go to 100% progress" do
-    config = deep_copy(standard_config)
-    config.options[:use_ansi] = true
-    bar = ProgressBar.new(0, Session.new(config), 'bla', 'blub')
-    bar.step
-    $stdout.string.count('.').should == ProgressBar::MAX_MARKERS
-    $stdout.string.should =~ /100%/
-
-    # Ensure we don't go over 100%
-    $stdout = StringIO.new
-    bar.step
-    $stdout.string.should == ''
-  end
-
-end

data/spec/proxied_table_scan_spec.rb

@@ -1,151 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe ProxiedTableScan do
-  before(:each) do
-    Initializer.configuration = deep_copy(proxied_config)
-
-    # Small block size necessary to exercize all code paths in ProxiedTableScan
-    # even when only using tables with very small number of records.
-    Initializer.configuration.options[:proxy_block_size] = 2
-
-    ensure_proxy
-  end
-
-  it "initialize should raise exception if session is not proxied" do
-    session = Session.new standard_config
-    lambda { ProxiedTableScan.new session, 'dummy_table' } \
-      .should raise_error(RuntimeError, /only works with proxied sessions/)
-  end
-
-  it "initialize should cache the primary keys" do
-    session = Session.new
-    scan = ProxiedTableScan.new session, 'scanner_records'
-    scan.primary_key_names.should == ['id']
-  end
-
-  it "initialize should raise exception if table doesn't have primary keys" do
-    session = Session.new
-    lambda {ProxiedTableScan.new session, 'extender_without_key'} \
-      .should raise_error(RuntimeError, /.*extender_without_key.*primary key/)
-  end
-  
-  it "block_size should return the :proxy_block_size value of the session options" do
-    ProxiedTableScan.new(Session.new, 'scanner_records').block_size \
-      .should == 2
-  end
-  
-  it "block_size should return the matching table specific option if available" do
-    config = Initializer.configuration
-    old_table_specific_options = config.tables_with_options
-    begin
-      config.options = {:proxy_block_size => 2}
-      config.include_tables 'scanner_records', {:proxy_block_size => 3}
-      ProxiedTableScan.new(Session.new(config), 'scanner_records').block_size \
-        .should == 3
-    ensure
-      config.instance_eval {@tables_with_options = old_table_specific_options}
-    end
-  end
-  
-  # Creates, prepares and returns a +ProxyBlockCursor+ for the given database 
-  # +connection+ and +table+.
-  # Sets the ProxyBlockCursor#max_row_cache_size as per method parameter.
-  def get_block_cursor(connection, table, max_row_cache_size = 1000000)
-    cursor = ProxyBlockCursor.new connection, table
-    cursor.max_row_cache_size = max_row_cache_size
-    cursor.prepare_fetch
-    cursor.checksum :proxy_block_size => 1000
-    cursor
-  end
-  
-  it "compare_blocks should compare all the records in the range" do
-    session = Session.new
-
-    left_cursor = get_block_cursor session.left, 'scanner_records'
-    right_cursor = get_block_cursor session.right, 'scanner_records'
-
-    scan = ProxiedTableScan.new session, 'scanner_records'
-    diff = []
-    scan.compare_blocks(left_cursor, right_cursor) do |type, row|
-      diff.push [type, row]
-    end
-    # in this scenario the right table has the 'highest' data, 
-    # so 'right-sided' data are already implicitely tested here
-    diff.should == [
-      [:conflict, [
-          {'id' => 2, 'name' => 'Bob - left database version'},
-          {'id' => 2, 'name' => 'Bob - right database version'}]],
-      [:left, {'id' => 3, 'name' => 'Charlie - exists in left database only'}],
-      [:right, {'id' => 4, 'name' => 'Dave - exists in right database only'}],
-      [:left, {'id' => 5, 'name' => 'Eve - exists in left database only'}],
-      [:right, {'id' => 6, 'name' => 'Fred - exists in right database only'}]
-    ]    
-  end
-  
-  it "compare_blocks should destroy the created cursors" do
-    session = Session.new
-
-    left_cursor = get_block_cursor session.left, 'scanner_records', 0
-    right_cursor = get_block_cursor session.right, 'scanner_records', 0
-
-    scan = ProxiedTableScan.new session, 'scanner_records'
-    scan.compare_blocks(left_cursor, right_cursor) { |type, row| }
-    
-    session.left.cursors.should == {}
-    session.right.cursors.should == {}
-  end
-  
-  it "run should only call compare single rows if there are different block checksums" do
-    config = deep_copy(proxied_config)
-    config.right = config.left
-    session = Session.new config
-    scan = ProxiedTableScan.new session, 'scanner_records'
-    scan.should_not_receive(:compare_blocks)
-    diff = []
-    scan.run do |type, row|
-      diff.push [type,row]      
-    end
-    diff.should == []
-  end
-  
-  it "run should compare all the records in the table" do
-    session = Session.new
-    scan = ProxiedTableScan.new session, 'scanner_records'
-    diff = []
-    scan.run do |type, row|
-      diff.push [type, row]
-    end
-    # in this scenario the right table has the 'highest' data, 
-    # so 'right-sided' data are already implicitely tested here
-    diff.should == [
-      [:conflict, [
-          {'id' => 2, 'name' => 'Bob - left database version'},
-          {'id' => 2, 'name' => 'Bob - right database version'}]],
-      [:left, {'id' => 3, 'name' => 'Charlie - exists in left database only'}],
-      [:right, {'id' => 4, 'name' => 'Dave - exists in right database only'}],
-      [:left, {'id' => 5, 'name' => 'Eve - exists in left database only'}],
-      [:right, {'id' => 6, 'name' => 'Fred - exists in right database only'}]
-    ]    
-  end
-
-  it "run should update the progress" do
-    session = Session.new
-    scan = ProxiedTableScan.new session, 'scanner_records'
-    number_steps = 0
-    scan.should_receive(:update_progress).any_number_of_times do |steps|
-      number_steps += steps
-    end
-    scan.run {|_, _|}
-    number_steps.should == 8
-  end
-
-  it "run should update the progress even if there are no records" do
-    # it should do that to ensure the progress bar is printed
-    scan = ProxiedTableScan.new Session.new, 'extender_no_record'
-    scan.should_receive(:update_progress).at_least(:once)
-    scan.run {|_, _|}
-  end
-end
-

data/spec/proxy_block_cursor_spec.rb

@@ -1,197 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe ProxyBlockCursor do
-  before(:each) do
-    @session = create_mock_proxy_connection 'dummy_table', ['dummy_id']
-    @cursor = ProxyBlockCursor.new @session, 'dummy_table'
-  end
-
-  it "initialize should super to ProxyCursor" do
-    @cursor.table.should == 'dummy_table'        
-  end
-  
-  it "next? should return true if there is an already loaded unprocessed row" do
-    @cursor.last_row = :dummy_row
-    @cursor.next?.should be_true
-  end
-  
-  it "next? should return true if the database cursor has more rows" do
-    table_cursor = mock("DBCursor")
-    table_cursor.should_receive(:next?).and_return(true)
-    @cursor.cursor = table_cursor
-
-    @cursor.next?.should be_true
-  end
-  
-  it "next? should return false if there are no loaded or unloaded unprocessed rows" do
-    table_cursor = mock("DBCursor")
-    table_cursor.should_receive(:next?).and_return(false)
-    @cursor.cursor = table_cursor
-
-    @cursor.next?.should be_false    
-  end
-  
-  it "next_row should return last loaded unprocessed row or nil if there is none" do
-    @cursor.last_row = :dummy_row
-
-    @cursor.next_row.should == :dummy_row
-    @cursor.last_row.should be_nil
-  end
-  
-  it "next_row should return next row in database if there is no loaded unprocessed row available" do
-    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 "reset_checksum should create a new empty SHA1 digest" do
-    @cursor.digest = :dummy_digest
-    @cursor.reset_checksum
-    @cursor.digest.should be_an_instance_of(Digest::SHA1) 
-  end
-  
-  it "reset_checksum should reset block variables" do
-    @cursor.reset_checksum
-    @cursor.row_checksums.should == []
-    @cursor.current_row_cache_size.should == 0
-    @cursor.row_cache.should == {}
-    
-  end
-  
-  it "update_checksum should update the existing digests" do
-    dummy_row1 = {'dummy_id' => 'dummy_value1'}
-    dummy_row2 = {'dummy_id' => 'dummy_value2'}
-    
-    @cursor.reset_checksum
-    @cursor.update_checksum dummy_row1
-    @cursor.update_checksum dummy_row2
-    
-    @cursor.current_checksum.should == Digest::SHA1.hexdigest(Marshal.dump(dummy_row1) + Marshal.dump(dummy_row2))
-    @cursor.row_checksums.should == [
-      {:row_keys => dummy_row1, :checksum => Digest::SHA1.hexdigest(Marshal.dump(dummy_row1))},
-      {:row_keys => dummy_row2, :checksum => Digest::SHA1.hexdigest(Marshal.dump(dummy_row2))},
-    ]
-    
-    @cursor.row_cache.should == {
-      Digest::SHA1.hexdigest(Marshal.dump(dummy_row1)) => Marshal.dump(dummy_row1),
-      Digest::SHA1.hexdigest(Marshal.dump(dummy_row2)) => Marshal.dump(dummy_row2)
-    }
-  end
-  
-  it "retrieve_row_cache should retrieve the specified elements" do
-    @cursor.row_cache = {'dummy_checksum' => 'bla'}
-    @cursor.retrieve_row_cache(['non_cached_row_checksum', 'dummy_checksum']).should ==
-      {'dummy_checksum' => 'bla'}
-  end
-  
-  it "current_checksum should return the current checksum" do
-    digest = mock("Digest")
-    digest.should_receive(:hexdigest).and_return(:dummy_checksum)
-    @cursor.digest = digest
-    
-    @cursor.current_checksum.should == :dummy_checksum
-  end
-  
-  it "checksum should reset the current digest" do
-    @cursor.reset_checksum # need to call it now so that for the call to checksum it can be mocked
-    @cursor.should_receive(:reset_checksum)
-    @cursor.should_receive(:next?).and_return(false)
-    @cursor.checksum :proxy_block_size => 1
-  end
-  
-  it "checksum should complain if neither :proxy_block_size nor :max_row are provided" do
-    lambda {@cursor.checksum}.should raise_error(
-      RuntimeError, 'options must include either :proxy_block_size or :max_row')
-  end
-  
-  it "checksum should verify options" do
-    lambda {@cursor.checksum}.should raise_error(
-      RuntimeError, 'options must include either :proxy_block_size or :max_row')
-    lambda {@cursor.checksum(:proxy_block_size => 0)}.should raise_error(
-      RuntimeError, ':proxy_block_size must be greater than 0')
-  end
-  
-  it "checksum should read maximum :proxy_block_size rows" do
-    session = ProxyConnection.new proxied_config.left
-
-    cursor = ProxyBlockCursor.new session, 'scanner_records'
-    cursor.prepare_fetch
-    
-    last_row, = cursor.checksum :proxy_block_size => 2
-    last_row.should == {'id' => 2} 
-
-    last_row, = cursor.checksum :proxy_block_size => 1000
-    last_row.should == {'id' => 5}
-  end
-  
-  it "checksum should read up to the specified :max_row" do
-    session = ProxyConnection.new proxied_config.left
-
-    cursor = ProxyBlockCursor.new session, 'scanner_records'
-    cursor.prepare_fetch
-    
-    last_row, = cursor.checksum :max_row => {'id' => 2}
-    last_row.should == {'id' => 2} 
-    last_row, = cursor.checksum :max_row => {'id' => 1000}
-    last_row.should == {'id' => 5} 
-  end
-  
-  it "checksum called with :proxy_block_size should return the correct checksum" do
-    session = ProxyConnection.new proxied_config.left
-
-    cursor = ProxyBlockCursor.new session, 'scanner_records'
-    cursor.prepare_fetch
-    
-    last_row , checksum = cursor.checksum :proxy_block_size => 2
- 
-    expected_checksum = Digest::SHA1.hexdigest( 
-      Marshal.dump('id' => 1, 'name' => 'Alice - exists in both databases') +
-      Marshal.dump('id' => 2, 'name' => 'Bob - left database version')
-    )
-    
-    checksum.should == expected_checksum
-  end
-
-  it "checksum called with :max_row should return the correct checksum" do
-    session = ProxyConnection.new proxied_config.left
-
-    cursor = ProxyBlockCursor.new session, 'scanner_records'
-    cursor.prepare_fetch
-    
-    last_row , checksum = cursor.checksum :max_row => {'id' => 2}
- 
-    expected_checksum = Digest::SHA1.hexdigest( 
-      Marshal.dump('id' => 1, 'name' => 'Alice - exists in both databases') +
-      Marshal.dump('id' => 2, 'name' => 'Bob - left database version')
-    )
-    
-    checksum.should == expected_checksum
-  end
-  
-  it "checksum called with :proxy_block_size should return the correct row count" do
-    session = ProxyConnection.new proxied_config.left
-
-    cursor = ProxyBlockCursor.new session, 'scanner_records'
-    cursor.prepare_fetch
-
-    _ , _, row_count = cursor.checksum :proxy_block_size => 2
-
-    row_count.should == 2
-  end
-
-  it "checksum called with :max_row should return the correct row count" do
-    session = ProxyConnection.new proxied_config.left
-
-    cursor = ProxyBlockCursor.new session, 'scanner_records'
-    cursor.prepare_fetch
-
-    _ , _, row_count = cursor.checksum :max_row => {'id' => 2}
-
-    row_count.should == 2
-  end
-
-end