bigrecord-driver 0.0.3

data/test/abstract_test_client.rb

@@ -0,0 +1,316 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'big_record_driver'
+
+module AbstractTestClient #< Test::Unit::TestCase
+
+  TABLE_NAME = :animals
+
+  def test_update_without_timestamps
+    ret = @big_db.update(TABLE_NAME,
+                         'dog-key',
+                        {'columnfamily1:name' => 'Dog',
+                         'columnfamily1:size' => 'medium',
+                         'columnfamily2:toto' => 'some value'})
+
+    assert_not_nil ret, "The row was not inserted properly"
+    assert_equal 'Dog', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:name'), "A saved cell couldn't be retrieved"
+    assert_equal 'medium', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size'), "A saved cell couldn't be retrieved"
+    assert_equal 'some value', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily2:toto'), "A saved cell couldn't be retrieved"
+  end
+
+  def test_update_with_timestamps_in_chronological_order
+    t1 = Time.now.to_i
+    t2 = t1 + 1000
+    t3 = t2 + 1000
+
+    ret1 = @big_db.update(TABLE_NAME,
+                          'dog-key',
+                         {'columnfamily1:name' => 'Dog',
+                          'columnfamily1:size' => 'medium',
+                          'columnfamily2:toto' => 'some value1'},
+                          t1)
+
+    ret2 = @big_db.update(TABLE_NAME,
+                          'dog-key',
+                         {'columnfamily1:size' => 'small',
+                          'columnfamily2:toto' => 'some value2'},
+                          t2)
+
+    ret3 = @big_db.update(TABLE_NAME,
+                          'dog-key',
+                         {'columnfamily1:size' => 'big'},
+                          t3)
+
+    assert_not_nil ret1, "A row was not inserted properly"
+    assert_not_nil ret2, "A row was not inserted properly"
+    assert_not_nil ret3, "A row was not inserted properly"
+
+    assert_equal 'Dog', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:name'), "A saved cell couldn't be retrieved"
+    assert_equal 'big', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size'), "A saved cell couldn't be retrieved"
+    assert_equal 'some value2', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily2:toto'), "A saved cell couldn't be retrieved"
+  end
+
+  def test_update_with_timestamps_in_reverse_chronological_order
+    t1 = Time.now.to_i
+    t2 = t1 - 1000
+    t3 = t2 - 1000
+
+    ret1 = @big_db.update(TABLE_NAME,
+                          'dog-key',
+                         {'columnfamily1:name' => 'Dog',
+                          'columnfamily1:size' => 'medium',
+                          'columnfamily2:toto' => 'some value1'},
+                          t1)
+
+    ret2 = @big_db.update(TABLE_NAME,
+                          'dog-key',
+                         {'columnfamily1:size' => 'small',
+                          'columnfamily2:toto' => 'some value2'},
+                          t2)
+
+    ret3 = @big_db.update(TABLE_NAME,
+                          'dog-key',
+                         {'columnfamily1:size' => 'big'},
+                          t3)
+
+    assert_not_nil ret1, "A row was not inserted properly"
+    assert_not_nil ret2, "A row was not inserted properly"
+    assert_not_nil ret3, "A row was not inserted properly"
+
+    assert_equal 'Dog', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:name'), "A saved cell couldn't be retrieved"
+    assert_equal 'medium', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size'), "A saved cell couldn't be retrieved"
+    assert_equal 'some value1', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily2:toto'), "A saved cell couldn't be retrieved"
+  end
+
+  def test_get_and_get_columns
+    t1 = Time.now.to_i
+    t2 = t1 + 1000
+    t3 = t2 + 1000
+
+    @big_db.update(TABLE_NAME,
+                    'dog-key',
+                   {'columnfamily1:name' => 'Dog',
+                    'columnfamily1:size' => 'medium',
+                    'columnfamily2:toto' => 'some value1'},
+                    t1)
+
+    @big_db.update(TABLE_NAME,
+                    'dog-key',
+                   {'columnfamily1:size' => 'small',
+                    'columnfamily2:toto' => 'some value2'},
+                    t2)
+
+    @big_db.update(TABLE_NAME,
+                    'dog-key',
+                   {'columnfamily1:size' => 'big'},
+                    t3)
+
+    # normal calls
+    assert_equal 'big', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size'), "Didn't retrieved the last version of the cell"
+    assert_nil @big_db.get(TABLE_NAME, 'dog-key-that-does-not-exist', 'columnfamily1:size'), "Got a value for a cell that doesn't even exist"
+
+    # timestamps
+    assert_equal 'medium', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :timestamp => t1), "Didn't retrieved the requested version of the cell"
+    assert_equal 'small', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :timestamp => t2), "Didn't retrieved the requested version of the cell"
+    assert_equal 'small', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :timestamp => t2+500), "Didn't retrieved the requested version of the cell"
+    assert_equal 'big', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :timestamp => t3), "Didn't retrieved the requested version of the cell"
+    assert_equal 'big', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :timestamp => t3+1000), "Didn't retrieved the last version of the cell"
+    assert_nil @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :timestamp => t1-1000), "Got a value for a cell that was not even existing at that time"
+
+    # num_versions
+    assert_raises ArgumentError, "Specifying a number of version = 0 should be forbidden" do
+      @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 0)
+    end
+    assert_raises ArgumentError, "Specifying a number of version < 0 should be forbidden" do
+      @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => -10)
+    end
+    assert_instance_of String, @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 1)
+    assert_instance_of Array, @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 2)
+    assert_equal 2, @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 2).size
+    assert_equal 3, @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 3).size
+    assert_equal 3, @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 10).size
+    assert_equal ['big', 'small', 'medium'], @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 10)
+
+    # timestamps + num_versions
+    assert_equal ['big', 'small', 'medium'], @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 10, :timestamp => t3+1000)
+    assert_equal ['big', 'small', 'medium'], @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 10, :timestamp => t3)
+    assert_equal ['small', 'medium'], @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 10, :timestamp => t2+500)
+    assert_equal ['small', 'medium'], @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 10, :timestamp => t2)
+    assert_equal ['medium'], @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 10, :timestamp => t1)
+    assert_equal [], @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 10, :timestamp => t1-1000)
+    assert_equal 'small', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 1, :timestamp => t2+500)
+    assert_nil @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size', :num_versions => 1, :timestamp => t1-500)
+
+
+    ###################### GET COLUMNS ######################
+    expected = {'id' => 'dog-key', 'columnfamily1:name' => 'Dog', 'columnfamily1:size' => 'big', 'columnfamily2:toto' => 'some value2'}
+    assert_equal expected, @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily1:name', 'columnfamily1:size', 'columnfamily2:toto']), "Didn't retrieved the expected data"
+
+    expected = {'id' => 'dog-key', 'columnfamily2:toto' => 'some value2'}
+    assert_equal expected, @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily2:toto']), "Didn't retrieved the expected data"
+
+    assert_nil @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily2:toto that does not exists']), "Didn't retrieved the expected data"
+
+    assert_nil @big_db.get_columns(TABLE_NAME, 'dog-key-akdfjlka', ['columnfamily2:toto']), "Retrieved values for a row that doesn't even exist"
+
+    expected = {'id' => 'dog-key', 'columnfamily1:name' => 'Dog', 'columnfamily1:size' => 'big', 'columnfamily2:toto' => 'some value2'}
+    assert_equal expected, @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily1:', 'columnfamily2:']), "Didn't retrieved the expected data"
+
+    expected = {'id' => 'dog-key', 'columnfamily1:name' => 'Dog', 'columnfamily1:size' => 'big', 'columnfamily2:toto' => 'some value2'}
+    assert_equal expected, @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily1:', 'columnfamily2:']), "Didn't retrieved the expected data"
+
+    expected = {'id' => 'dog-key', 'columnfamily1:name' => 'Dog', 'columnfamily2:toto' => 'some value2'}
+    assert_equal expected, @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily1:name', 'columnfamily2:']), "Didn't retrieved the expected data"
+
+    expected = {'id' => 'dog-key', 'columnfamily1:name' => 'Dog', 'columnfamily1:size' => 'big'}
+    assert_equal expected, @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily1:']), "Didn't retrieved the expected data"
+
+    expected = {'id' => 'dog-key', 'columnfamily1:name' => 'Dog', 'columnfamily1:size' => 'small'}
+    assert_equal expected, @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily1:'], :timestamp => t2), "Didn't retrieved the expected data"
+
+    assert_nil @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily1:'], :timestamp => t1-500), "Didn't retrieved the expected data"
+
+    expected = {'id' => 'dog-key', 'columnfamily1:name' => 'Dog', 'columnfamily1:size' => 'big'}
+    assert_equal expected, @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily1:'], :timestamp => t3+500), "Didn't retrieved the expected data"
+  end
+
+  def test_get_consecutive_rows
+    @big_db.update(TABLE_NAME,
+                    'dog-key',
+                   {'columnfamily1:name' => 'Dog',
+                    'columnfamily1:size' => 'medium',
+                    'columnfamily2:description' => 'lives on earth',
+                    'columnfamily2:$pt-707' => '343220'})
+    @big_db.update(TABLE_NAME,
+                    'fish-key',
+                   {'columnfamily1:name' => 'Fish',
+                    'columnfamily1:size' => 'varies but usually small',
+                    'columnfamily2:description' => 'must stay in water'})
+    @big_db.update(TABLE_NAME,
+                    'mouse-key',
+                   {'columnfamily1:name' => 'Mouse',
+                    'columnfamily1:size' => 'small',
+                    'columnfamily2:description' => 'cats love them'})
+    @big_db.update(TABLE_NAME,
+                    'cat-key',
+                   {'columnfamily1:name' => 'Cat',
+                    'columnfamily1:size' => 'small but bigger than a mouse and smaller than a dog',
+                    'columnfamily2:description' => 'likes mice'})
+
+    # find(:all)
+    expected = [{'id' => 'cat-key', 'columnfamily1:name' => 'Cat', 'columnfamily1:size' => 'small but bigger than a mouse and smaller than a dog', 'columnfamily2:description' => 'likes mice'},
+                {'id' => 'dog-key', 'columnfamily1:name' => 'Dog', 'columnfamily1:size' => 'medium', 'columnfamily2:description' => 'lives on earth', 'columnfamily2:$pt-707' => '343220'},
+                {'id' => 'fish-key', 'columnfamily1:name' => 'Fish', 'columnfamily1:size' => 'varies but usually small', 'columnfamily2:description' => 'must stay in water'},
+                {'id' => 'mouse-key', 'columnfamily1:name' => 'Mouse', 'columnfamily1:size' => 'small', 'columnfamily2:description' => 'cats love them'}]
+
+    assert_equal expected, @big_db.get_consecutive_rows(TABLE_NAME, nil, nil, ['columnfamily1:', 'columnfamily2:']), "Didn't retrieved the expected data"
+
+    # find(:all, :condition => ...)
+    expected = [{'id' => 'cat-key', 'columnfamily1:name' => 'Cat', 'columnfamily2:description' => 'likes mice'},
+                {'id' => 'dog-key', 'columnfamily1:name' => 'Dog', 'columnfamily2:description' => 'lives on earth', 'columnfamily2:$pt-707' => '343220'},
+                {'id' => 'fish-key', 'columnfamily1:name' => 'Fish', 'columnfamily2:description' => 'must stay in water'},
+                {'id' => 'mouse-key', 'columnfamily1:name' => 'Mouse', 'columnfamily2:description' => 'cats love them'}]
+
+    assert_equal expected, @big_db.get_consecutive_rows(TABLE_NAME, nil, nil, ['columnfamily1:name', 'columnfamily2:']), "Didn't retrieved the expected data"
+
+    # find(:all, :offset => before_first_row)
+    expected = [{'id' => 'cat-key', 'columnfamily1:name' => 'Cat'},
+                {'id' => 'dog-key', 'columnfamily1:name' => 'Dog'},
+                {'id' => 'fish-key', 'columnfamily1:name' => 'Fish'},
+                {'id' => 'mouse-key', 'columnfamily1:name' => 'Mouse'}]
+
+    assert_equal expected, @big_db.get_consecutive_rows(TABLE_NAME, 'aaa-key', nil, ['columnfamily1:name']), "Didn't retrieved the expected data"
+
+    # find(:all, :offset => n_row)
+    expected = [{'id' => 'fish-key', 'columnfamily1:name' => 'Fish'},
+                {'id' => 'mouse-key', 'columnfamily1:name' => 'Mouse'}]
+
+    assert_equal expected, @big_db.get_consecutive_rows(TABLE_NAME, 'fish-key', nil, ['columnfamily1:name']), "Didn't retrieved the expected data"
+
+    # find(:all, :limit > highest key)
+    expected = [{'id' => 'cat-key', 'columnfamily1:name' => 'Cat'},
+                {'id' => 'dog-key', 'columnfamily1:name' => 'Dog'},
+                {'id' => 'fish-key', 'columnfamily1:name' => 'Fish'},
+                {'id' => 'mouse-key', 'columnfamily1:name' => 'Mouse'}]
+
+    assert_equal expected, @big_db.get_consecutive_rows(TABLE_NAME, nil, 1000, ['columnfamily1:name']), "Didn't retrieved the expected data"
+
+    # find(:all, :limit => x)
+    expected = [{'id' => 'cat-key', 'columnfamily1:name' => 'Cat'},
+                {'id' => 'dog-key', 'columnfamily1:name' => 'Dog'}]
+
+    assert_equal expected, @big_db.get_consecutive_rows(TABLE_NAME, nil, 2, ['columnfamily1:name']), "Didn't retrieved the expected data"
+
+    # find(:all, :offset => n_row, :limit => x)
+    expected = [{'id' => 'fish-key', 'columnfamily1:name' => 'Fish'},
+                {'id' => 'mouse-key', 'columnfamily1:name' => 'Mouse'}]
+
+    assert_equal expected, @big_db.get_consecutive_rows(TABLE_NAME, 'fish-key', 2, ['columnfamily1:name']), "Didn't retrieved the expected data"
+
+    # find(:all, :offset => n_row, :limit => 1)
+    expected = [{'id' => 'fish-key', 'columnfamily1:name' => 'Fish'}]
+
+    assert_equal expected, @big_db.get_consecutive_rows(TABLE_NAME, 'fish-key', 1, ['columnfamily1:name']), "Didn't retrieved the expected data"
+  end
+
+  def test_delete
+    @big_db.update(TABLE_NAME,
+                    'dog-key',
+                   {'columnfamily1:name' => 'Dog',
+                    'columnfamily1:size' => 'medium',
+                    'columnfamily2:description' => 'lives on earth'})
+    @big_db.update(TABLE_NAME,
+                    'fish-key',
+                   {'columnfamily1:name' => 'Fish',
+                    'columnfamily1:size' => 'varies but usually small',
+                    'columnfamily2:description' => 'must stay in water'})
+
+    # make sure the cells are there
+    expected = [{'id' => 'dog-key', 'columnfamily1:name' => 'Dog', 'columnfamily1:size' => 'medium', 'columnfamily2:description' => 'lives on earth'},
+                {'id' => 'fish-key', 'columnfamily1:name' => 'Fish', 'columnfamily1:size' => 'varies but usually small', 'columnfamily2:description' => 'must stay in water'}]
+    assert_equal expected, @big_db.get_consecutive_rows(TABLE_NAME, nil, nil, ['columnfamily1:', 'columnfamily2:']), "The test data was not inserted properly"
+
+    # actual test
+    @big_db.delete(TABLE_NAME, 'dog-key')
+
+    expected = [{'id' => 'fish-key', 'columnfamily1:name' => 'Fish', 'columnfamily1:size' => 'varies but usually small', 'columnfamily2:description' => 'must stay in water'}]
+    assert_equal expected, @big_db.get_consecutive_rows(TABLE_NAME, nil, nil, ['columnfamily1:', 'columnfamily2:']), "The deleted data was found by a scanner"
+
+    assert_nil @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:name'), "The deleted data was found by a get()"
+
+    assert_nil @big_db.get_columns(TABLE_NAME, 'dog-key', ['columnfamily1:']), "The deleted data was found by a get_columns()"
+  end
+
+  def test_ping
+    db = nil
+    assert_nothing_raised("Couldn't initialize the client") do
+      db = BigRecordDriver::Client.new(:drb_port => 40005)
+    end
+    assert_not_nil db, "Couldn't initialize the client"
+    assert db.ping, "The client was initialized but we cannot communicate with the db itself"
+  end
+
+  def test_table_exists
+    assert @big_db.table_exists?(TABLE_NAME)
+    assert !@big_db.table_exists?(:some_non_existent_table)
+  end
+
+  def test_table_names
+    assert @big_db.table_names.include?(TABLE_NAME.to_s)
+  end
+
+  def test_method_missing
+    assert_raises NoMethodError do
+      @big_db.akdfjlajfl
+    end
+  end
+
+  def test_invalid_column_family
+    assert_raises BigRecordDriver::JavaError do
+      @big_db.get(TABLE_NAME, 'dog-key', 'nonexistentcolumnfamily:name')
+    end
+  end
+
+end

data/test/test_client_cassandra.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/abstract_test_client'
+
+class TestCassandraClient < Test::Unit::TestCase
+  include AbstractTestClient
+
+  def setup
+    unless @big_db
+      BigRecordDriver::DriverManager.set_cmd('cassandra')
+      unless BigRecordDriver::DriverManager.running?(40005)
+        BigRecordDriver::DriverManager.restart(40005)
+      end
+      #TODO: don't use hard coded values for the config
+      @big_db = BigRecordDriver::Client.new(:drb_port => 40005)
+    end
+  end
+  
+ def test_update_without_timestamps
+
+  end
+
+  def test_update_with_timestamps_in_chronological_order
+  end
+
+  def test_update_with_timestamps_in_reverse_chronological_order
+  end
+
+  def test_get_and_get_columns
+    t1 = Time.now.to_i
+    t2 = t1 + 1000
+    t3 = t2 + 1000
+    # Temporary copy-paste until all tests passes
+    @big_db.update(TABLE_NAME,
+                    'dog-key',
+                   {'columnfamily1:name' => 'Dog',
+                    'columnfamily1:size' => 'medium',
+                    'columnfamily2:toto' => 'some value1'},
+                    t1)
+
+    @big_db.update(TABLE_NAME,
+                    'dog-key',
+                   {'columnfamily1:size' => 'small',
+                    'columnfamily2:toto' => 'some value2'},
+                    t2)
+
+    @big_db.update(TABLE_NAME,
+                    'dog-key',
+                   {'columnfamily1:size' => 'big'},
+                    t3)
+
+    # normal calls
+    assert_equal 'big', @big_db.get(TABLE_NAME, 'dog-key', 'columnfamily1:size'), "Didn't retrieved the last version of the cell"
+    assert_nil @big_db.get(TABLE_NAME, 'dog-key-that-does-not-exist', 'columnfamily1:size'), "Got a value for a cell that doesn't even exist"
+  end
+
+  def test_get_consecutive_rows
+  end
+
+  def test_delete
+  end
+
+  def test_invalid_column_family
+  end
+end

data/test/test_client_hbase.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/abstract_test_client'
+
+class TestHbaseClient < Test::Unit::TestCase #TestClient
+  include AbstractTestClient
+  # Prepare the connection and the test tables.
+  def setup
+    unless @big_db
+      unless BigRecordDriver::DriverManager.running?(40005)
+        BigRecordDriver::DriverManager.restart(40005)
+      end
+
+      #TODO: don't use hard coded values for the config
+      @big_db = BigRecordDriver::Client.new(:zookeeper_quorum=> 'localhost', :zookeeper_client_port => '2181',:drb_port => 40005)
+    end
+
+    @big_db.drop_table(TABLE_NAME) if @big_db.table_exists?(TABLE_NAME)
+
+    # Create the test table
+    # unless @big_db.table_exists?(TABLE_NAME)
+      columns_descriptors = []
+      columns_descriptors << BigRecordDriver::ColumnDescriptor.new(:columnfamily1)
+      columns_descriptors << BigRecordDriver::ColumnDescriptor.new(:columnfamily2)
+      @big_db.create_table(TABLE_NAME, columns_descriptors)
+    # end
+  end
+end

data/test/test_driver_manager.rb

@@ -0,0 +1,46 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'big_record_driver'
+
+class TestDriverManager < Test::Unit::TestCase
+
+  # everything is in a sequence and therefore there's only 1 test
+  def test_all
+    port = 40000
+  
+    # stop the driver if it's already running
+    assert_nothing_raised do
+      BigRecordDriver::DriverManager.stop(port) if BigRecordDriver::DriverManager.running?(port)
+    end
+    assert !BigRecordDriver::DriverManager.running?(port), "The driver is already running and it couldn't be stopped"
+
+    # start the real tests
+    assert_nothing_raised do
+      BigRecordDriver::DriverManager.start(port)
+    end
+    assert BigRecordDriver::DriverManager.running?(port), "The driver couldn't be started"
+    
+    assert_nothing_raised do
+      BigRecordDriver::DriverManager.restart(port)
+    end
+    assert BigRecordDriver::DriverManager.running?(port), "The driver couldn't be restarted"
+    
+    assert_nothing_raised("The driver should be able to do a silent start when it's already running") do
+      BigRecordDriver::DriverManager.silent_start(port)
+    end
+    assert BigRecordDriver::DriverManager.running?(port), "The driver stopped during a silent start instead of staying alive"
+
+    assert_nothing_raised do
+      BigRecordDriver::DriverManager.stop(port)
+    end
+    assert !BigRecordDriver::DriverManager.running?(port), "The driver couldn't be stopped"
+    
+    assert_nothing_raised("The driver should be able to do a silent start when it's not running") do
+      BigRecordDriver::DriverManager.silent_start(port)
+    end
+    assert BigRecordDriver::DriverManager.running?(port), "The driver couldn't be started silently"
+
+  end
+  
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: bigrecord-driver
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- openplaces.org
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-12 00:00:00 -04:00
+default_executable: hbase-driver
+dependencies: []
+
+description: Bigrecord drivers that use JRuby DRb servers to connect with databases through their native Java APIs. Currently supported databases are HBase and Cassandra.
+email: bigrecord@openplaces.org
+executables: 
+- hbase-driver
+- cassandra-driver
+- launcher
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- bin/cassandra-driver
+- bin/hbase-driver
+- bin/launcher
+- conf/log4j.properties
+- lib/big_record_driver.rb
+- lib/big_record_driver/bigrecord_server.rb
+- lib/big_record_driver/cassandra_driver/server.rb
+- lib/big_record_driver/client.rb
+- lib/big_record_driver/column_descriptor.rb
+- lib/big_record_driver/driver_manager.rb
+- lib/big_record_driver/exceptions.rb
+- lib/big_record_driver/hbase_driver/server.rb
+- lib/bigrecord_driver.rb
+- test/abstract_test_client.rb
+- test/test_client_cassandra.rb
+- test/test_client_hbase.rb
+- test/test_driver_manager.rb
+- vendor/java/cassandra/cassandra-0.3.0-dev.jar
+- vendor/java/cassandra/libthrift.jar
+- vendor/java/cassandra/log4j-1.2.15.jar
+- vendor/java/hbase/commons-logging-1.0.4.jar
+- vendor/java/hbase/commons-logging-api-1.0.4.jar
+- vendor/java/hbase/hadoop-0.20.0-core.jar
+- vendor/java/hbase/hbase-0.20.0.jar
+- vendor/java/hbase/log4j-1.2.13.jar
+- vendor/java/hbase/zookeeper-r785019-hbase-1329.jar
+- README
+has_rdoc: true
+homepage: http://www.bigrecord.org
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Bigrecord drivers implemented as JRuby DRb servers
+test_files: []
+