simpleOracleJDBC 0.1

data/test/db_call_test.rb

@@ -0,0 +1,91 @@
+require 'helper'
+
+class DBCallTest < Test::Unit::TestCase
+
+  include TestHelper
+
+  def setup
+    @interface = @@interface
+  end
+
+  def teardown
+  end
+
+  def test_class_method_prepare_returns_correct_object
+    call_obj = SimpleOracleJDBC::DBCall.prepare(@interface.connection, 'begin :out := :in; end;')
+    assert(call_obj.is_a? SimpleOracleJDBC::DBCall)
+    call_obj.close
+  end
+
+  def test_class_method_execute_returns_correct_object
+    call_obj = SimpleOracleJDBC::DBCall.execute(@interface.connection,
+                                                'begin :out := :in; end;',
+                                                [String, nil, :out], 'ABC')
+    assert(call_obj.is_a? SimpleOracleJDBC::DBCall)
+    assert_equal(call_obj[1], 'ABC')
+    call_obj.close
+  end
+
+  def test_class_method_execute_works_with_jdbc_type_calls
+    call_obj = SimpleOracleJDBC::DBCall.execute(@interface.connection,
+                                                '{ call ? := ? }',
+                                                [String, nil, :out], 'ABC')
+    assert(call_obj.is_a? SimpleOracleJDBC::DBCall)
+    assert_equal(call_obj[1], 'ABC')
+    call_obj.close
+  end
+
+  def test_prepared_call_can_be_executed_and_returns_self
+    call_obj = SimpleOracleJDBC::DBCall.prepare(@interface.connection, 'begin :out := :in; end;')
+    results = nil
+    assert_nothing_raised do
+      results = call_obj.execute([String, nil, :out], 'ABC')
+    end
+    assert_equal(results, call_obj)
+    call_obj.close
+  end
+
+  def test_accessing_bind_out_of_range_raises_exception
+    call_obj = SimpleOracleJDBC::DBCall.execute(@interface.connection,
+                                                '{ call ? := ? }',
+                                                [String, nil, :out], 'ABC')
+    assert_raises SimpleOracleJDBC::BindIndexOutOfRange do
+      call_obj[0]
+    end
+    call_obj.close
+  end
+
+  def test_in_binds_can_be_retrieved
+    call_obj = SimpleOracleJDBC::DBCall.execute(@interface.connection,
+                                                "begin :out := :in||'DEF'; end;",
+                                                [String, nil, :out], 'ABC')
+    assert_equal(call_obj[2], 'ABC')
+    call_obj.close
+  end
+
+  def test_out_bind_can_be_retrieved
+    call_obj = SimpleOracleJDBC::DBCall.execute(@interface.connection,
+                                                "begin :out := :in||'DEF'; end;",
+                                                [String, nil, :out], 'ABC')
+    assert_equal(call_obj[1], 'ABCDEF')
+    call_obj.close
+  end
+
+  def test_close_method_closes_statment
+    call_obj = SimpleOracleJDBC::DBCall.execute(@interface.connection,
+                                                "begin :out := :in||'DEF'; end;",
+                                                [String, nil, :out], 'ABC')
+    assert_not_nil(call_obj.call)
+    call_obj.close
+    assert_nil(call_obj.call)
+  end
+
+  def test_raw_jdbc_call_object_can_be_retrieved
+    call_obj = SimpleOracleJDBC::DBCall.execute(@interface.connection,
+                                                "begin :out := :in||'DEF'; end;",
+                                                [String, nil, :out], 'ABC')
+    assert_not_nil(call_obj.call)
+  end
+
+
+end

data/test/helper.rb

@@ -0,0 +1,20 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'simple_oracle_jdbc'
+require 'test/unit'
+
+module TestHelper
+
+  DB_USER     = 'sodonnel'
+  DB_PASSWORD = 'sodonnel'
+  DB_SERVICE  = 'local11gr2.world'
+  DB_HOST     = 'localhost'
+  DB_PORT     = '1521'
+
+  @@interface ||= SimpleOracleJDBC::Interface.create(DB_USER,
+                                                     DB_PASSWORD,
+                                                     DB_SERVICE,
+                                                     DB_HOST,
+                                                     DB_PORT)
+end

data/test/interface_test.rb

@@ -0,0 +1,76 @@
+require 'helper'
+
+class InterfaceTest < Test::Unit::TestCase
+
+  include TestHelper
+
+  def setup
+    @interface = SimpleOracleJDBC::Interface.create(DB_USER,
+                                                    DB_PASSWORD,
+                                                    DB_SERVICE,
+                                                    DB_HOST,
+                                                    DB_PORT)
+  end
+
+  def teardown
+    @interface.disconnect
+  end
+
+  def test_interface_can_be_created_with_connection_details
+    # the interface is created in setup
+    assert_not_nil(@interface)
+  end
+
+  def test_raw_database_connection_accessible
+    connection = @interface.connection
+    # should return a JDBC connection object - test to see if it responds
+    # to a JDBC method
+    assert(connection.respond_to? :prepare_statement)
+  end
+
+  def test_disconnect_method_closes_db_connection
+    @interface.disconnect
+    assert_nil(@interface.connection)
+  end
+
+  def test_commit_method_available
+    assert_nothing_raised do
+      @interface.commit
+    end
+  end
+
+  def test_rollback_method_available
+    assert_nothing_raised do
+      @interface.rollback
+    end
+  end
+
+  def test_prepare_sql_query_returns_sql_object
+    sql = @interface.prepare_sql("select * from dual")
+    assert(sql.is_a? SimpleOracleJDBC::Sql)
+    sql.close
+  end
+
+  def test_execute_sql_query_returns_sql_object
+    sql = @interface.execute_sql("select * from dual")
+    assert(sql.is_a? SimpleOracleJDBC::Sql)
+    sql.close
+  end
+
+  def test_prepare_call_returns_db_call_object
+    call = @interface.prepare_proc("begin
+                                     :l_date := :i_date;
+                                   end;")
+    assert(call.is_a? SimpleOracleJDBC::DBCall)
+  end
+
+  def test_execute_call_returns_an_executed_db_call_object
+    call = @interface.execute_proc("begin
+                                     :l_date := :i_date;
+                                   end;", [Time, nil, :out], Time.now)
+    assert(call.is_a? SimpleOracleJDBC::DBCall)
+  end
+
+
+end
+

data/test/result_set_test.rb

@@ -0,0 +1,128 @@
+require 'helper'
+
+class ResultSetTest < Test::Unit::TestCase
+
+  include TestHelper
+
+  def setup
+    @@interface ||= SimpleOracleJDBC::Interface.create('sodonnel',
+                                                       'sodonnel',
+                                                       'local11gr2.world',
+                                                       'localhost',
+                                                       '1521'
+                                                       )
+    @interface = @@interface
+
+
+    @sql = SimpleOracleJDBC::Sql.execute(@interface.connection,
+                 "select 'a' a_val,
+                         1   b_val
+                  from dual
+                  union all
+                  select 'aa' a_val,
+                          2   b_val
+                  from dual")
+  end
+
+  def teardown
+    @sql.close
+  end
+
+
+  def test_each_array_returns_array_per_row
+    rows = 0
+    @sql.each_array do |r|
+      assert(r.is_a? Array)
+      rows += 1
+    end
+    assert_equal(2, rows)
+  end
+
+  def test_next_array_returns_a_row_per_call
+    row = @sql.next_array
+    assert_equal(row[0], 'a')
+    assert_equal(row[1], 1)
+    row = @sql.next_array
+    assert_equal(row[0], 'aa')
+    assert_equal(row[1], 2)
+    row = @sql.next_array
+    assert_nil(row)
+    # After getting a nil row, it indicates the end of the result set
+    # another fetch will raise an exception as the result set will have
+    # been closed
+    assert_raises SimpleOracleJDBC::NoResultSet do
+      row = @sql.next_array
+    end
+  end
+
+  def test_all_array_returns_all_rows_as_array_or_arrays
+    rows = @sql.all_array
+    assert_equal(rows.length, 2)
+    assert_equal(rows[0][0], 'a')
+    assert_equal(rows[0][1], 1)
+    assert_equal(rows[1][0], 'aa')
+    assert_equal(rows[1][1], 2)
+    # A second call to all_array will error
+    assert_raises SimpleOracleJDBC::NoResultSet do
+      row = @sql.all_array
+    end
+  end
+
+  def test_each_hash_returns_hash_per_row
+    rows = 0
+    @sql.each_hash do |r|
+      assert(r.is_a? Hash)
+      assert(r.has_key? 'A_VAL')
+      assert(r.has_key? 'B_VAL')
+      rows += 1
+    end
+    assert_equal(2, rows)
+  end
+
+  def test_next_hash_returns_a_hash_per_call
+    row = @sql.next_hash
+    assert_equal(row['A_VAL'], 'a')
+    assert_equal(row['B_VAL'], 1)
+    row = @sql.next_hash
+    assert_equal(row['A_VAL'], 'aa')
+    assert_equal(row['B_VAL'], 2)
+    row = @sql.next_hash
+    assert_nil(row)
+    # After getting a nil row, it indicates the end of the result set
+    # another fetch will raise an exception as the result set will have
+    # been closed
+    assert_raises SimpleOracleJDBC::NoResultSet do
+      row = @sql.next_hash
+    end
+  end
+
+  def test_all_hash_returns_all_rows_as_array_of_hashes
+    rows = @sql.all_hash
+    assert_equal(rows.length, 2)
+    assert_equal(rows[0]['A_VAL'], 'a')
+    assert_equal(rows[0]['B_VAL'], 1)
+    assert_equal(rows[1]['A_VAL'], 'aa')
+    assert_equal(rows[1]['B_VAL'], 2)
+    # A second call to all_hash will error
+    assert_raises SimpleOracleJDBC::NoResultSet do
+      row = @sql.all_hash
+    end
+  end
+
+  def test_close_result_set
+    assert_nothing_raised do
+      @sql.close_result_set
+    end
+  end
+
+  def test_all_retrieves_fail_when_no_or_closed_result_set
+    calls = [:all_array, :each_array, :next_array, :all_hash, :each_hash, :next_hash]
+    @sql.close_result_set
+    calls.each do |c|
+      assert_raises SimpleOracleJDBC::NoResultSet do
+        @sql.send(c)
+      end
+    end
+  end
+
+end

data/test/sql_test.rb

@@ -0,0 +1,73 @@
+require 'helper'
+
+class SqlTest < Test::Unit::TestCase
+
+  include TestHelper
+
+  def setup
+    @interface = @@interface
+    @sql = SimpleOracleJDBC::Sql.new
+  end
+
+  def teardown
+    @sql.close
+  end
+
+  def test_class_method_prepare_returns_correct_object
+    sql_obj = SimpleOracleJDBC::Sql.prepare(@interface.connection, 'select * from dual')
+    assert(sql_obj.is_a? SimpleOracleJDBC::Sql)
+    results = sql_obj.execute.all_array
+    assert_equal(results.length, 1)
+  end
+
+  def test_class_method_execute_returns_correct_object
+    sql_obj = SimpleOracleJDBC::Sql.execute(@interface.connection, 'select * from dual')
+    assert(sql_obj.is_a? SimpleOracleJDBC::Sql)
+  end
+
+  def test_class_method_execute_allows_binds_to_be_set
+    sql_obj = SimpleOracleJDBC::Sql.execute(@interface.connection,
+                                            'select * from dual where 1 = ? and 2 = ?',
+                                            1, 2)
+    results = sql_obj.all_array
+    assert_equal(results.length, 1)
+  end
+
+  def test_prepare_method_available_and_returns_self
+    sql_obj = SimpleOracleJDBC::Sql.new
+    prepared = sql_obj.prepare(@interface.connection, 'select * from dual')
+    assert_equal(prepared, sql_obj)
+  end
+
+  def test_execute_method_avaliable_and_returns_self
+    sql_obj = SimpleOracleJDBC::Sql.prepare(@interface.connection, 'select * from dual')
+    executed = sql_obj.execute
+    assert_equal(executed, sql_obj)
+  end
+
+  def test_execute_method_accepts_binds_correctly_and_returns_self
+    sql_obj = SimpleOracleJDBC::Sql.prepare(@interface.connection,
+                                            "select * from dual where 1 = ? and 'a' = ? and 1.234 = ?")
+    #"
+    executed = sql_obj.execute(1, 'a', 1.234)
+    assert_equal(executed, sql_obj)
+    results = sql_obj.all_array
+    assert_equal(results.length, 1)
+    assert_equal(results[0][0], 'X')
+  end
+
+  def test_close_does_not_error_when_no_statement
+    sql_obj = SimpleOracleJDBC::Sql.new
+    assert_nothing_raised do
+      sql_obj.close
+    end
+  end
+
+  def test_close_does_not_error_when_statement_exists
+    sql_obj = SimpleOracleJDBC::Sql.prepare(@interface.connection, 'select * from dual')
+    assert_nothing_raised do
+      sql_obj.close
+    end
+  end
+
+end

data/test/test_runner.rb

@@ -0,0 +1,14 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+current_dir = File.expand_path(File.dirname(__FILE__))
+
+require "simple_oracle_jdbc"
+require 'test/unit'
+
+
+
+# Find all files that end in _test.rb and require them ...
+files = Dir.entries(current_dir).grep(/^[^#].+_test\.rb$/).sort
+files.each do |f|
+  require File.join(current_dir, f)
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: simpleOracleJDBC
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Stephen O'Donnell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-05 00:00:00.000000000 Z
+dependencies: []
+description: A lightweight wrapper around the JDBC interface to make it easier to
+  make SQL and stored procedure calls.
+email: stephen@betteratoracle.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- test/binding_test.rb
+- test/db_call_test.rb
+- test/helper.rb
+- test/interface_test.rb
+- test/result_set_test.rb
+- test/sql_test.rb
+- test/test_runner.rb
+- lib/simple_oracle_jdbc/bindings.rb
+- lib/simple_oracle_jdbc/db_call.rb
+- lib/simple_oracle_jdbc/interface.rb
+- lib/simple_oracle_jdbc/result_set.rb
+- lib/simple_oracle_jdbc/sql.rb
+- lib/simple_oracle_jdbc.rb
+- Rakefile.rb
+- README.md
+homepage: http://betteratoracle.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A gem to simplify JDBC database access to Oracle when using JRuby
+test_files: []