ibruby 0.5.5-i686-darwin8.9.1

data/test/KeyTest.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class KeyTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}key_unit_test.ib"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      
+      # Switch to the old way of keying.
+      $IBRubySettings[:ALIAS_KEYS] = false
+      
+      database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connection  = database.connect(DB_USER_NAME, DB_PASSWORD)
+      @transaction = @connection.start_transaction
+      @results     = ResultSet.new(@connection, @transaction,
+                                   'SELECT * FROM RDB$FIELDS', 3, nil)
+      @empty       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                      0, 0, 0, 0, 0, 0, 0, 0, 0]
+      
+      @connection.execute_immediate('create table keytest (COL01 integer, '\
+                                    'COL02 varchar(10), COL03 integer)')
+      @connection.execute_immediate("insert into keytest values (1, 'Two', 3)")
+   end
+   
+   def teardown
+      @results.close
+      @transaction.rollback
+      @connection.close
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      $IBRubySettings[:ALIAS_KEYS] = true
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test_01
+      sql  = 'select COL01 one, COL02 two, COL03 three from keytest'
+      rows = @connection.execute_immediate(sql)
+      data = rows.fetch
+      
+      count = 0
+      data.each do |name, value|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+         assert([1, 'Two', 3].include?(value))
+         count += 1
+      end
+      assert(count == 3)
+      
+      count = 0
+      data.each_key do |name|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+         count += 1
+      end
+      assert(count == 3)
+      
+      count = 0
+      data.each_value do |value|
+         assert([1, 'Two', 3].include?(value))
+         count += 1
+      end
+      assert(count == 3)
+      
+      assert(data.fetch('COL02') == 'Two')
+      assert(data.fetch('COL04', 'LALALA') == 'LALALA')
+      assert(data.fetch('COL00') {'NOT FOUND'} == 'NOT FOUND')
+      begin
+         data.fetch('COL05')
+         assert(false, 'Row#fetch succeeded for non-existent column name.')
+      rescue IndexError
+      end
+      
+      assert(data.has_key?('COL01'))
+      assert(data.has_key?('COL10') == false)
+      
+      assert(data.has_column?('COL02'))
+      assert(data.has_column?('COL22') == false)
+      
+      assert(data.has_alias?('TWO'))
+      assert(data.has_alias?('FOUR') == false)
+      
+      assert(data.has_value?(3))
+      assert(data.has_value?('LALALA') == false)
+      
+      assert(data.keys.size == 3)
+      data.keys.each do |name|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+      end
+      
+      assert(data.names.size == 3)
+      data.names.each do |name|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+      end
+
+      assert(data.aliases.size == 3)
+      data.aliases.each do |name|
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
+      end
+      
+      assert(data.values.size == 3)
+      data.values.each do |value|
+         assert([1, 'Two', 3].include?(value))
+      end
+      
+      array = data.select {|name, value| name == 'COL02'}
+      assert(array.size == 1)
+      assert(array[0][0] == 'COL02')
+      assert(array[0][1] == 'Two')
+      
+      array = data.to_a
+      assert(array.size == 3)
+      assert(array.include?(['COL01', 1]))
+      assert(array.include?(['COL02', 'Two']))
+      assert(array.include?(['COL03', 3]))
+      
+      hash = data.to_hash
+      assert(hash.length == 3)
+      assert(hash['COL01'] == 1)
+      assert(hash['COL02'] == 'Two')
+      assert(hash['COL03'] == 3)
+      
+      array = data.values_at('COL10', 'COL02', 'COL03')
+      assert(array.size == 3)
+      assert(array.include?('Two'))
+      assert(array.include?(3))
+      assert(array.include?(nil))
+      
+      rows.close
+   end
+end

data/test/KeyTest.rb.rej

@@ -0,0 +1,17 @@
+***************
+*** 9,15 ****
+  
+  class KeyTest < Test::Unit::TestCase
+     CURDIR  = "#{Dir.getwd}"
+-    DB_FILE = "#{CURDIR}#{File::SEPARATOR}key_unit_test.fdb"
+     
+     def setup
+        puts "#{self.class.name} started." if TEST_LOGGING
+--- 9,15 ----
+  
+  class KeyTest < Test::Unit::TestCase
+     CURDIR  = "#{Dir.getwd}"
++    DB_FILE = "#{CURDIR}#{File::SEPARATOR}key_unit_test.ib"
+     
+     def setup
+        puts "#{self.class.name} started." if TEST_LOGGING

data/test/MetaTest.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class MetaTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}meta_unit_test.ib"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+      @database    = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connection = @database.connect(DB_USER_NAME, DB_PASSWORD)
+      
+      @creation_sql = "create table mtest (id integer not null, "\
+        "bool1 boolean default false, bool2 boolean, bool3 boolean default true, bool4 boolean default true not null,"\
+        " blob1 blob sub_type 1 not null, blob2 blob sub_type 1, blob3 blob sub_type 0,"\
+        " char1 char(10) default 'fred', char2 char(10) default 'fred' not null, char3 char(10), char4 char(20) default 'wil''ma',"\
+        " date1 date default current_date, date2 date not null, date3 date default current_date not null,"\
+        " decimal1 decimal(18,5) default 1.345, decimal2 decimal(15,5) default 20.22 not null, decimal3 decimal(12,6) not null"\
+        ")"
+      #puts sql
+      @connection.execute_immediate( @creation_sql );
+      @connection.execute_immediate( "create table pk_table(id integer not null primary key)" )
+      @connection.execute_immediate( "create table fk_table(id integer not null primary key, "\
+        "fk_id integer references pk_table(id))" )
+      @pk_sql = "alter table mtest "
+      
+   end
+   
+  
+   def teardown
+      @connection.close
+
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test01
+     table = InterBaseTable.new('mtest')
+     assert_nothing_thrown( "failed to load table mtest" ) { table.load(@connection) }
+     sql = []
+     assert_nothing_thrown( "unable to build sql!" ) { sql = table.to_sql }
+     assert_not_nil sql, "sql returned nil for create table"
+     assert_equal sql.size > 0, true, "sql returned has nothing in it for table creation!"
+     #assert_equal @creation_sql.upcase, sql[0].upcase
+     #they ARE the same, but shows false and don't know why
+     puts sql
+   end
+   
+   def test02
+    col = InterBaseMetaFunctions.table_fields( @connection, "mtest", true, "decimal2" )
+    new_col = col.dup
+    new_col.precision = 16
+    new_col.scale = 2
+    col.change_column(@connection,new_col)
+    new_col = InterBaseMetaFunctions.table_fields( @connection, "mtest", true, "decimal2" )
+    
+    assert_equal false, new_col == col, "column decimal2 not changed"
+    assert_equal new_col.precision, 16, "column decimal2 precision not 16!"
+    assert_equal new_col.scale, 2, "column scale should be 2!"
+   end
+   
+   def test03
+     col = InterBaseMetaFunctions.table_fields( @connection, "mtest", true, "decimal2" )
+     col.rename_column( @connection, "decimal_rename" )
+     ren_col = InterBaseMetaFunctions.table_fields( @connection, "mtest", true, "decimal2" )
+     assert_equal nil, ren_col, "column not renamed!"
+     new_col = InterBaseMetaFunctions.table_fields( @connection, "mtest", true, "decimal_rename" )
+     assert_equal new_col, col, "column types not identical after rename"
+     new_col.rename_column( @connection, "decimal2" )
+   end
+
+   def test04
+     table = InterBaseTable.new('fk_table')
+     table.load(@connection)
+     assert_nothing_thrown( "unable build sql for table fk_table! " ) do
+       table.to_sql.each() {|sql| puts "table creation sql: #{sql}" }
+     end
+     assert_nothing_thrown( "unable to rename table" ) do
+       table.rename_table( @connection, 'new_fk_table' )
+     end
+     table = InterBaseTable.new('new_fk_table')
+     table.load(@connection)
+     assert_nothing_thrown( "unable build sql for table fk_table! " ) do
+       table.to_sql.each() {|sql| puts "table creation sql: #{sql}" }
+     end
+   end   
+ end

data/test/ResultSetTest.rb

@@ -0,0 +1,164 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class ResultSetTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}result_set_unit_test.ib"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connections  = []
+      @transactions = []
+      
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      
+      @connections[0].start_transaction do |tx|
+         tx.execute("CREATE TABLE TEST_TABLE (TESTID INTEGER NOT NULL "\
+                    "primary KEY, TESTINFO VARCHAR(100))")
+         tx.execute('create table all_types (col01 boolean, col02 blob, '\
+                    'col03 char(100), col04 date, col05 decimal(5,2), '\
+                    'col06 double precision, col07 float, col08 integer, '\
+                    'col09 numeric(10,3), col10 smallint, col11 time, '\
+                    'col12 timestamp, col13 varchar(23))')
+      end
+      
+      @connections[0].start_transaction do |tx|
+         begin
+            tx.execute("INSERT INTO TEST_TABLE VALUES (10, 'Record One.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (20, 'Record Two.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (30, 'Record Three.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (40, 'Record Four.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (50, 'Record Five.')")
+         rescue Exception => error
+            puts error.message
+            error.backtrace.each {|step| puts "   #{step}"}
+            raise
+         end
+      end
+      
+      @transactions.push(@connections[0].start_transaction)
+   end
+   
+   def teardown
+      @transactions.each do |tx|
+         tx.rollback if tx.active?
+      end
+      @transactions.clear
+      @connections.each do |cxn|
+         cxn.close if cxn.open?
+      end
+      @connections.clear
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test01
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
+      
+      assert(r.connection == @connections[0])
+      assert(r.transaction == @transactions[0])
+      assert(r.sql == "SELECT * FROM TEST_TABLE ORDER BY TESTID")
+      assert(r.dialect == 3)
+      
+      assert(r.fetch != nil)
+      assert(r.fetch.class == Row)
+      assert(r.fetch[0] == 30)
+      assert(r.fetch[1] == 'Record Four.')
+      r.fetch
+      assert(r.fetch == nil)
+      r.close
+      
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
+      assert(r.column_count == 2)
+      assert(r.column_name(0) == 'TESTID')
+      assert(r.column_name(1) == 'TESTINFO')
+      assert(r.column_name(3) == nil)
+      assert(r.column_name(-1) == nil)
+      assert(r.column_table(0) == 'TEST_TABLE')
+      assert(r.column_table(1) == 'TEST_TABLE')
+      assert(r.column_table(2) == nil)
+      assert(r.column_table(-1) == nil)
+      assert(r.column_alias(0) == 'TESTID')
+      assert(r.column_alias(1) == 'TESTINFO')
+      assert(r.column_alias(3) == nil)
+      assert(r.column_alias(-1) == nil)
+      r.close
+      
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
+      total = 0
+      r.each do |row|
+         total += 1
+      end
+      assert(total == 5)
+      assert(r.exhausted?)
+   end
+
+   def test02
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        'select * from test_table where testid between ? and ?',
+                        3, [20, 40])
+      assert(r.exhausted? == false)
+      total = 0
+      r.each {|row| total += 1}
+      assert(total == 3)
+      assert(r.exhausted?)
+   end
+
+   def test03
+      begin
+         ResultSet.new(@connections[0], @transactions[0],
+                       "insert into test_table values(?, ?)", 3,
+                       [100, 'Should fail.'])
+         assert(false, "Created result set with non-query SQL statement.")
+      rescue IBRubyException
+      end
+
+      begin
+         ResultSet.new(@connections[0], @transactions[0],
+                       "select * from test_table where testid = ?", 3,
+                       [])
+         assert(false, 'Created result set with insufficient parameters.')
+      rescue IBRubyException
+      end
+   end
+   
+   def test04
+      results = nil
+      begin
+         results = @transactions[0].execute('select * from all_types')
+        
+         #assert(results.get_base_type(0) == SQLType::BIGINT)
+         puts "blob=#{results.get_base_type(0)}"
+         puts "blob=#{results.get_base_type(2)}"
+         assert(results.get_base_type(1) == SQLType::BLOB)
+         assert(results.get_base_type(2) == SQLType::CHAR)
+         assert(results.get_base_type(3) == SQLType::DATE)
+         assert(results.get_base_type(4) == SQLType::DECIMAL)
+         assert(results.get_base_type(5) == SQLType::DOUBLE)
+         assert(results.get_base_type(6) == SQLType::FLOAT)
+         assert(results.get_base_type(7) == SQLType::INTEGER)
+         assert(results.get_base_type(8) == SQLType::NUMERIC)
+         assert(results.get_base_type(9) == SQLType::SMALLINT)
+         assert(results.get_base_type(10) == SQLType::TIME)
+         assert(results.get_base_type(11) == SQLType::TIMESTAMP)
+         assert(results.get_base_type(12) == SQLType::VARCHAR)
+      ensure
+         results.close if results != nil
+      end
+   end
+end

data/test/RoleTest.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+# This test case isn't working as I cannot get the basic operation of roles to work under ISQL so I am unsure
+# how they are supposed to work.
+
+class DatabaseTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}role_unit_test.ib"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File.exist?(DB_FILE)
+         db = Database.new(DB_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+#connect "role_unit_test.ib" user "newuser" password "password" role sales;
+#insert into sales_test values(1);
+      Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      createUser
+      createRoleAndAllocate
+    end
+    
+    def createUser
+      #create the user we will use to grant permission to
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      au = AddUser.new('newuser', 'password', 'first', 'middle', 'last')
+      au.execute(sm)
+      sm.disconnect
+    end
+    
+    def createRoleAndAllocate
+      database = Database::new(DB_FILE)
+      @connection = database.connect(DB_USER_NAME, DB_PASSWORD)
+      @connection.execute_immediate( 'create role sales' )
+      @connection.execute_immediate( 'create table sales_test(sales_drone integer)' )
+      @connection.execute_immediate( 'grant insert on sales_test to sales' )
+      # no permission to this table (notsales)
+      @connection.execute_immediate( 'create table notsales(sales_drone integer)' )
+      # add 'newuser' into sales role
+      @connection.execute_immediate( 'grant sales to newuser' )
+      @connection.close
+    end
+    
+    def dropRole
+     database = Database::new(DB_FILE)
+     @connection = database.connect(DB_USER_NAME, DB_PASSWORD)
+     @connection.execute_immediate( 'drop role sales' )
+     @connection.close
+   end
+   
+   def dropUser
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      au = RemoveUser.new('newuser')
+      au.execute(sm)
+      sm.disconnect
+   end
+   
+   def teardown
+      dropRole
+      dropUser
+      
+      if File::exist?(DB_FILE)
+         db = Database.new(DB_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+      
+   #test we can connect with the role
+   def test02
+     database = Database::new(DB_FILE)
+     @connection = database.connect('newuser', 'password', Connection::ROLE => 'SALES' )
+     assert_nothing_raised() do
+     
+       assert(@connection.execute_immediate( 'insert into sales_test values(1)' ) == 1 )
+     
+     end
+     @connection.close
+   end
+   
+   def test01
+     database = Database::new(DB_FILE)
+     @connection = database.connect('newuser', 'password' )
+     assert_raise(IBRuby::IBRubyException) do
+       @connection.execute_immediate( 'insert into sales_test values(10)' )
+       
+       puts "No role passed but can insert into sales_test!" if TEST_LOGGING
+     end
+     @connection.close
+   end
+   
+end

data/test/RowCountTest.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class RowCountTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}row_count_test.ib"
+
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      # Create the database for use in testing.
+      if File.exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      @database = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      
+      # Create the test table.
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('create table test(id integer)')
+      end
+   end
+   
+   
+   def teardown
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test01
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.start_transaction do |tx|
+            assert(cxn.execute_immediate('insert into test values (1000)') == 1)
+            assert(cxn.execute_immediate('insert into test values (1000)') == 1)
+            assert(cxn.execute('insert into test values (2000)', tx) == 1)
+            assert(cxn.execute('insert into test values (2000)', tx) == 1)
+            assert(tx.execute('insert into test values (3000)') == 1)
+            assert(tx.execute('insert into test values (3000)') == 1)
+            assert(tx.execute('insert into test values (4000)') == 1)
+            assert(tx.execute('insert into test values (4000)') == 1)
+            
+            assert(cxn.execute_immediate('update test set id = 10000 where '\
+                                         'id = 1000') == 2)
+            assert(cxn.execute('update test set id = 20000 where id = 2000',
+                               tx) == 2)
+            assert(tx.execute('update test set id = 30000 where id = 3000') == 2)
+            
+            s = Statement.new(cxn, tx, 'update test set id = 40000 where id = ?',
+                              3)
+            assert(s.execute_for([4000]) == 2)
+
+            
+            assert(cxn.execute_immediate('delete from test where id = 10000') == 2)
+            assert(cxn.execute('delete from test where id = 20000', tx) == 2)
+            assert(tx.execute('delete from test where id = 30000') == 2)
+         end
+      end
+   end
+end