rubyrep 1.0.0

data/spec/proxy_connection_spec.rb

@@ -0,0 +1,399 @@
+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
+    @connection.destroy
+
+    @connection.connection.active?.should == false
+  end
+
+  it "refresh should not do anything if the connection is still active" do
+    ConnectionExtenders.should_not_receive(:db_connect)
+    @connection.refresh
+  end
+
+  it "refresh should reestablish the connection if it is no more active" do
+    @connection.destroy
+    @connection.refresh
+    @connection.connection.should be_active
+  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
+
+  it "select_cursor should forwarded the handed over query" do
+    @connection.connection.should_receive(:select_cursor).with('bla', 123)
+    @connection.select_cursor(:query => 'bla', :row_buffer_size => 123)
+  end
+
+  it "select_cursor should use the default row buffer size if no explicit value is specified" do
+    @connection.connection.should_receive(:select_cursor) \
+      .with('bla', ProxyConnection::DEFAULT_ROW_BUFFER_SIZE)
+    @connection.select_cursor(:query => 'bla')
+  end
+
+  it "select_cursor should construct the query and execute it" do
+    @connection.connection.should_receive(:select_cursor) \
+      .with(sql_to_regexp('select "id", "name" from "scanner_records" order by "id"'), ProxyConnection::DEFAULT_ROW_BUFFER_SIZE)
+    @connection.select_cursor(:table => 'scanner_records')
+  end
+
+  it "select_cursor should return a type casting cursor if :type_cast option is specified" do
+    @connection.select_cursor(:table => 'scanner_records').
+      should_not be_an_instance_of(TypeCastingCursor)
+    @connection.select_cursor(:table => 'scanner_records', :type_cast => true).
+      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_one("select * from scanner_records where 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_one(
+        "select first_id, second_id 
+         from extender_combined_key where (first_id, second_id) = (8, 9)") \
+        .should == {'first_id' => '8', 'second_id' => '9'}
+    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_one(
+        "select first_id, second_id, name 
+         from extender_combined_key where (first_id, second_id) = (8, 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_one("select * from scanner_records where id = 1") \
+        .should == {'id' => '1', 'name' => 'update_test'}
+    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_one(
+        "select first_id, second_id, name
+         from extender_combined_key where (first_id, second_id) = (1, 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_one(
+        "select first_id, second_id, name
+         from extender_combined_key where (first_id, second_id) = (8, 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_one(
+        "select first_id, second_id, name
+         from extender_combined_key where (first_id, second_id) = (1, 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)
+
+      org_cursor = @connection.select_cursor(:query => "select * from extender_type_check where id = 1")
+      cursor = TypeCastingCursor.new @connection, 'extender_type_check', org_cursor
+      result_data = cursor.next_row
+      result_data.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
+
+end

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