andyjeffries-rubyrep 1.2.1

data/spec/proxied_table_scan_spec.rb

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

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

data/spec/proxy_connection_spec.rb

@@ -0,0 +1,423 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ProxyConnection do
+  before(:each) do
+    Initializer.configuration = proxied_config
+    @connection = ProxyConnection.new Initializer.configuration.left
+  end
+
+  it "initialize should connect to the database" do
+    (!!@connection.connection.active?).should == true
+  end
+
+  it "initialize should store the configuratin" do
+    @connection.config.should == Initializer.configuration.left
+  end
+  
+  it "destroy should disconnect from the database" do
+    if ActiveSupport.const_defined?(:Notifications)
+      ConnectionExtenders::install_logger @connection.connection, :logger => StringIO.new
+      log_subscriber = @connection.connection.log_subscriber
+
+      ActiveSupport::Notifications.notifier.listeners_for("sql.active_record").should include(log_subscriber)
+    end
+
+    @connection.destroy
+
+    if ActiveSupport.const_defined?(:Notifications)
+      ActiveSupport::Notifications.notifier.listeners_for("sql.active_record").should_not include(log_subscriber)
+      @connection.connection.log_subscriber.should be_nil
+    end
+
+    (!!@connection.connection.active?).should == false
+  end
+
+  it "cursors should return the current cursor hash or an empty hash if nil" do
+    @connection.cursors.should == {}
+    @connection.cursors[:dummy_cursor] = :dummy_cursor
+    @connection.cursors.should == {:dummy_cursor => :dummy_cursor}    
+  end
+  
+  it "save_cursor should register the provided cursor" do
+    @connection.save_cursor :dummy_cursor
+    
+    @connection.cursors[:dummy_cursor].should == :dummy_cursor
+  end
+  
+  it "destroy should destroy and unregister any stored cursors" do
+    cursor = mock("Cursor")
+    cursor.should_receive(:destroy)
+    
+    @connection.save_cursor cursor
+    @connection.destroy
+    
+    @connection.cursors.should == {}
+  end
+
+  it "destroy_cursor should destroy and unregister the provided cursor" do
+    cursor = mock("Cursor")
+    cursor.should_receive(:destroy)
+    
+    @connection.save_cursor cursor
+    @connection.destroy_cursor cursor
+    
+    @connection.cursors.should == {}
+  end
+  
+  it "create_cursor should create and register the cursor and initiate row fetching" do
+    cursor = @connection.create_cursor(
+      ProxyRowCursor, 
+      'scanner_records',
+      :from => {'id' => 2},
+      :to => {'id' => 2}
+    )
+
+    cursor.should be_an_instance_of(ProxyRowCursor)
+    cursor.next_row_keys_and_checksum[0].should == {'id' => 2} # verify that 'from' range was used
+    cursor.next?.should be_false # verify that 'to' range was used
+  end
+  
+  it "column_names should return the column names of the specified table" do
+    @connection.column_names('scanner_records').should == ['id', 'name']
+  end
+  
+  it "column_names should cache the column names" do
+    @connection.column_names('scanner_records')
+    @connection.column_names('scanner_text_key')
+    @connection.connection.should_not_receive(:columns)
+    @connection.column_names('scanner_records').should == ['id', 'name']
+  end
+  
+  it "primary_key_names should return the correct primary keys" do
+    @connection.primary_key_names('scanner_records').should == ['id']
+  end
+
+  it "primary_key_names should return the manual primary keys if they exist" do
+    @connection.stub!(:manual_primary_keys).
+      and_return({'scanner_records' => ['manual_key']})
+    @connection.primary_key_names('scanner_records').should == ['manual_key']
+  end
+
+  it "primary_key_names should not cache or manually overwrite if :raw option is given" do
+    @connection.stub!(:manual_primary_keys).
+      and_return({'scanner_records' => ['manual_key']})
+    key1 = @connection.primary_key_names('scanner_records', :raw => true)
+    key1.should == ['id']
+
+    key2 = @connection.primary_key_names('scanner_records', :raw => true)
+    key1.__id__.should_not == key2.__id__
+  end
+
+  it "primary_key_names should cache the primary primary keys" do
+    @connection.connection.should_receive(:primary_key_names) \
+      .with('dummy_table').once.and_return(['dummy_key'])
+    @connection.connection.should_receive(:primary_key_names) \
+      .with('dummy_table2').once.and_return(['dummy_key2'])
+    
+    @connection.primary_key_names('dummy_table').should == ['dummy_key']
+    @connection.primary_key_names('dummy_table2').should == ['dummy_key2']
+    @connection.primary_key_names('dummy_table').should == ['dummy_key']
+  end
+
+  # Note:
+  # Additional select_cursor tests are executed via
+  # 'db_specific_connection_extenders_spec.rb'
+  # (To verify the behaviour for all supported databases)
+
+  it "select_cursor should return the result fetcher" do
+    fetcher = @connection.select_cursor(:table => 'scanner_records', :type_cast => false)
+    fetcher.connection.should == @connection
+    fetcher.options.should == {:table => 'scanner_records', :type_cast => false}
+  end
+
+  it "select_cursor should return a type casting cursor if :type_cast option is specified" do
+    fetcher = @connection.select_cursor(:table => 'scanner_records', :type_cast => true)
+    fetcher.should be_an_instance_of(TypeCastingCursor)
+  end
+
+  it "table_select_query should handle queries without any conditions" do
+    @connection.table_select_query('scanner_records') \
+      .should =~ sql_to_regexp("\
+        select 'id', 'name' from 'scanner_records'\
+        order by 'id'")
+  end
+  
+  it "table_select_query should handle queries with only a from condition" do
+    @connection.table_select_query('scanner_records', :from => {'id' => 1}) \
+      .should =~ sql_to_regexp("\
+         select 'id', 'name' from 'scanner_records' \
+         where ('id') >= (1) order by 'id'")
+  end
+  
+  it "table_select_query should handle queries with an exclusive from condition" do
+    @connection.table_select_query(
+      'scanner_records',
+      :from => {'id' => 1},
+      :exclude_starting_row => true
+    ).should =~ sql_to_regexp("\
+      select 'id', 'name' from 'scanner_records' \
+      where ('id') > (1) order by 'id'")
+  end
+
+  it "table_select_query should handle queries with only a to condition" do
+    @connection.table_select_query('scanner_text_key', :to => {'text_id' => 'k1'}) \
+      .should =~ sql_to_regexp("\
+         select 'text_id', 'name' from 'scanner_text_key' \
+         where ('text_id') <= ('k1') order by 'text_id'")
+  end
+  
+  it "table_select_query should handle queries with both from and to conditions" do
+    @connection.table_select_query('scanner_records', 
+      :from => {'id' => 0}, :to => {'id' => 1}) \
+      .should =~ sql_to_regexp("\
+        select 'id', 'name' from 'scanner_records' \
+        where ('id') >= (0) and ('id') <= (1) order by 'id'")
+  end
+  
+  it "table_select_query should handle queries for specific rows" do
+    @connection.table_select_query('scanner_records',
+      :row_keys => [{'id' => 0}, {'id' => 1}]) \
+      .should =~ sql_to_regexp("\
+        select 'id', 'name' from 'scanner_records' \
+        where ('id') in ((0), (1)) order by 'id'")
+  end
+  
+  it "table_select_query should handle queries for specific rows with the row array actually being empty" do
+    @connection.table_select_query('scanner_records', :row_keys => []) \
+      .should =~ sql_to_regexp("\
+        select 'id', 'name' from 'scanner_records' \
+        where false order by 'id'")
+  end
+  
+  it "table_select_query should handle queries for specific rows in combination with other conditions" do
+    @connection.table_select_query('scanner_records',
+      :from => {'id' => 0},
+      :row_keys => [{'id' => 1}, {'id' => 2}]) \
+      .should =~ sql_to_regexp("\
+        select 'id', 'name' from 'scanner_records' \
+        where ('id') >= (0) and ('id') in ((1), (2)) order by 'id'")
+  end
+  
+  it "table_select_query should handle tables with combined primary keys" do
+    @connection.table_select_query('extender_combined_key',
+      :from => {'first_id' => 0, 'second_id' => 1}, 
+      :to => {'first_id' => 2, 'second_id' => 3}) \
+      .should =~ sql_to_regexp("\
+        select 'first_id', 'second_id', 'name' from 'extender_combined_key' \
+        where ('first_id', 'second_id') >= (0, 1) \
+        and ('first_id', 'second_id') <= (2, 3) \
+        order by 'first_id', 'second_id'")
+  end
+  
+  it "table_select_query should quote column values" do
+    select_options = {:from => {'text_id' => 'a'}, :to => {'text_id' => 'b'}}
+    
+    @connection.table_select_query('scanner_text_key', select_options) \
+      .should match(/'a'.*'b'/)
+    
+    # additional check that the quoted query actually works
+    cursor = ProxyCursor.new(@connection, 'scanner_text_key')
+    results = cursor.prepare_fetch(select_options)
+    results.next_row.should == {'text_id' => 'a', 'name' => 'Alice'}
+    results.next_row.should == {'text_id' => 'b', 'name' => 'Bob'}
+    results.next?.should be_false
+  end
+  
+  it "table_insert_query should return the correct SQL query" do
+    @connection.table_insert_query('scanner_records', 'name' => 'bla') \
+      .should =~ sql_to_regexp(%q!insert into "scanner_records"("name") values("bla")!)
+  end
+  
+  it "insert_record should insert the specified record" do
+    @connection.begin_db_transaction
+    begin
+      @connection.insert_record('scanner_records', 'id' => 9, 'name' => 'bla')
+      @connection.select_record(
+        :table => 'scanner_records',
+        :row_keys => ['id' => 9]
+      ).should == {'id' => 9, 'name' => 'bla'}
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+
+  it "insert_record should handle combined primary keys" do
+    @connection.begin_db_transaction
+    begin
+      @connection.insert_record('extender_combined_key', 'first_id' => 8, 'second_id' => '9')
+      @connection.select_record(
+        :table => 'extender_combined_key',
+        :row_keys => ['first_id' => 8, 'second_id' => 9]
+      ).should == {'first_id' => 8, 'second_id' => 9, 'name' => nil}
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+  
+  it "insert_record should write nil values correctly" do
+    @connection.begin_db_transaction
+    begin
+      @connection.insert_record('extender_combined_key', 'first_id' => 8, 'second_id' => '9', 'name' => nil)
+      @connection.select_record(
+        :table => 'extender_combined_key',
+        :row_keys => ['first_id' => 8, 'second_id' => 9]
+      ).should == {'first_id' => 8, 'second_id' => 9, "name" => nil}
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+
+  it "insert_record should also insert uncommon data types correctly" do
+    @connection.begin_db_transaction
+    begin
+      test_data = {
+        'id' => 2, 
+        'decimal_test' => 1.234,
+        'timestamp' => Time.local(2008,"jun",9,20,15,1),
+        'multi_byte' => "よろしくお願(ねが)いします yoroshiku onegai shimasu: I humbly ask for your favor.",
+        'binary_test' => Marshal.dump(['bla',:dummy,1,2,3]),
+        'text_test' => 'dummy text'
+      }
+      @connection.insert_record('extender_type_check', test_data)
+
+      cursor = @connection.select_cursor(
+        :table => 'extender_type_check',
+        :row_keys => [{'id' => 2}],
+        :type_cast => true
+      )
+      result_data = cursor.next_row
+      result_data.should == test_data
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+  
+  it "table_update_query should return the correct SQL query" do
+    @connection.table_update_query('scanner_records', 'id' => 1) \
+      .should =~ sql_to_regexp(%q!update "scanner_records" set "id" = 1 where ("id") = (1)!)
+  end
+  
+  it "update_record should update the specified record" do
+    @connection.begin_db_transaction
+    begin
+      @connection.update_record('scanner_records', 'id' => 1, 'name' => 'update_test')
+      @connection.select_record(
+        :table => "scanner_records",
+        :row_keys => ['id' => 1]
+      ).should == {'id' => 1, 'name' => 'update_test'}
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+
+  it "update_record should return the number of updated records" do
+    @connection.begin_db_transaction
+    begin
+      @connection.
+        update_record('scanner_records', 'id' => 1, 'name' => 'update_test').
+        should == 1
+      @connection.
+        update_record('scanner_records', 'id' => 0, 'name' => 'update_test').
+        should == 0
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+
+  it "update_record should handle combined primary keys" do
+    @connection.begin_db_transaction
+    begin
+      @connection.update_record('extender_combined_key', 'first_id' => 1, 'second_id' => '1', 'name' => 'xy')
+      @connection.select_record(
+        :table => 'extender_combined_key',
+        :row_keys => ['first_id' => 1, 'second_id' => 1]
+      ).should == {'first_id' => 1, 'second_id' => 1, 'name' => 'xy'}
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+
+  it "update_record should handle key changes" do
+    @connection.begin_db_transaction
+    begin
+      @connection.update_record 'extender_combined_key',
+        {'first_id' => '8', 'second_id' => '9', 'name' => 'xy'},
+        {'first_id' => '1', 'second_id' => '1'}
+      @connection.select_record(
+        :table => 'extender_combined_key',
+        :row_keys => ['first_id' => 8, 'second_id' => 9]
+      ).should == {'first_id' => 8, 'second_id' => 9, 'name' => 'xy'}
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+
+  it "update_record should write nil values correctly" do
+    @connection.begin_db_transaction
+    begin
+      @connection.update_record('extender_combined_key', 'first_id' => 1, 'second_id' => '1', 'name' => nil)
+      @connection.select_record(
+        :table => 'extender_combined_key',
+        :row_keys => ['first_id' => 1, 'second_id' => 1]
+      ).should == {'first_id' => 1, 'second_id' => 1, 'name' => nil}
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+
+  it "update_record should also update uncommon data types correctly" do
+    @connection.begin_db_transaction
+    begin
+      test_data = {
+        'id' => 1, 
+        'decimal_test' => 0.234,
+        'timestamp' => Time.local(2009,"jun",9,20,15,1),
+        'multi_byte' => "よろしくお願(ねが)いします yoroshiku onegai shimasu: I humbly ask for your favor. bla",
+        'binary_test' => Marshal.dump(['bla',:dummy,1,2,3,4]),
+        'text_test' => 'dummy text bla'
+      }
+      @connection.update_record('extender_type_check', test_data)
+
+      @connection.select_record(
+        :table => "extender_type_check",
+        :row_keys => ["id" => 1]
+      ).should == test_data
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+
+  it "table_delete_query should return the correct SQL query" do
+    @connection.table_delete_query('scanner_records', 'id' => 1) \
+      .should =~ sql_to_regexp(%q!delete from "scanner_records" where ("id") = (1)!)
+  end
+  
+  it "delete_record should delete the specified record" do
+    @connection.begin_db_transaction
+    begin
+      @connection.delete_record('extender_combined_key', 'first_id' => 1, 'second_id' => '1', 'name' => 'xy')
+      @connection.select_one(
+        "select first_id, second_id, name
+         from extender_combined_key where (first_id, second_id) = (1, 1)") \
+        .should be_nil
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+
+  it "delete_record should return the number of deleted records" do
+    @connection.begin_db_transaction
+    begin
+      @connection.
+        delete_record('extender_combined_key', 'first_id' => 1, 'second_id' => '1').
+        should == 1
+      @connection.
+        delete_record('extender_combined_key', 'first_id' => 1, 'second_id' => '0').
+        should == 0
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+end