rubyfb 0.5.2-x86-mswin32-60

data/test/DatabaseTest.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class DatabaseTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}db_unit_test.fdb"
+   CREATE_FILE = "#{CURDIR}#{File::SEPARATOR}db_create_test.fdb"
+   
+   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
+      if File.exist?(CREATE_FILE)
+         db = Database.new(CREATE_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      
+      Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, 'ASCII')
+   end
+   
+   def teardown
+      if File::exist?(DB_FILE)
+         db = Database.new(DB_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      if File::exist?(CREATE_FILE)
+         db = Database.new(CREATE_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   
+   def test01
+      db = Database.create(CREATE_FILE, DB_USER_NAME, DB_PASSWORD, 2048, 'ASCII')
+      
+      assert(File.exist?(CREATE_FILE))
+      assert(db.file == CREATE_FILE)
+      
+      begin
+         Database.create(CREATE_FILE, DB_USER_NAME, DB_PASSWORD, 2048, 'ASCII')
+         assert(false,
+                "Successfully created a database file that already exists.")
+      rescue Exception
+      end
+      
+      db.drop(DB_USER_NAME, DB_PASSWORD)
+      assert(File.exist?(CREATE_FILE) == false)
+   end
+   
+   def test02
+      db = Database.new(DB_FILE);
+      
+      assert(db.file == DB_FILE)
+      
+      c = db.connect(DB_USER_NAME, DB_PASSWORD)
+      assert(c != nil)
+      c.close
+   end
+   
+   def test03
+      db = Database.new(DB_FILE);
+      c  = nil
+
+      db.connect(DB_USER_NAME, DB_PASSWORD) do |connection|
+         assert(connection != nil)
+         assert(connection.class == Connection)
+         assert(connection.open?)
+         c = connection
+      end
+      assert(c != nil)
+      assert(c.class == Connection)
+      assert(c.closed?)
+   end
+end

data/test/GeneratorTest.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class GeneratorTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}generator_unit_test.fdb"
+   
+   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  = []
+      
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+   end
+   
+   def teardown
+      @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
+      assert(Generator::exists?('TEST_GEN', @connections[0]) == false)
+      g = Generator::create('TEST_GEN', @connections[0])
+      assert(Generator::exists?('TEST_GEN', @connections[0]))
+      assert(g.last == 0)
+      assert(g.next(1) == 1)
+      assert(g.last == 1)
+      assert(g.next(10) == 11)
+      assert(g.connection == @connections[0])
+      assert(g.name == 'TEST_GEN')
+      
+      g.drop
+      assert(Generator::exists?('TEST_GEN', @connections[0]) == false)
+   end
+end

data/test/KeyTest.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+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
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      
+      # Switch to the old way of keying.
+      $FireRubySettings[: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
+      $FireRubySettings[: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/ResultSetTest.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class ResultSetTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}result_set_unit_test.fdb"
+   
+   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 bigint, 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 FireRubyException
+      end
+
+      begin
+         ResultSet.new(@connections[0], @transactions[0],
+                       "select * from test_table where testid = ?", 3,
+                       [])
+         assert(false, 'Created result set with insufficient parameters.')
+      rescue FireRubyException
+      end
+   end
+   
+   def test04
+      results = nil
+      begin
+         results = @transactions[0].execute('select * from all_types')
+        
+         assert(results.get_base_type(0) == SQLType::BIGINT)
+         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,73 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class RoleTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}role_unit_test.fdb"
+
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      # Remove existing database files.
+      @database = Database.new(DB_FILE)
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+
+      @sm = ServiceManager.new('localhost')
+      @sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      au = AddUser.new('user1', 'password', 'first', 'middle', 'last')
+      au.execute(@sm)
+      sleep(3)
+   end
+
+   def teardown
+      ru = RemoveUser.new('user1')
+      ru.execute(@sm)
+      sleep(3)
+
+      @sm.disconnect
+
+      # Remove existing database files.
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+
+   def test01
+      cxn = @database.connect(DB_USER_NAME, DB_PASSWORD)
+      cxn.execute_immediate('CREATE TABLE TEST (field1 INTEGER)')
+      cxn.execute_immediate('CREATE role myrole')
+      cxn.execute_immediate('GRANT myrole to user1')
+      cxn.execute_immediate('GRANT ALL on TEST to myrole')
+      cxn.close
+
+      cxn = @database.connect('user1', 'password')      
+      assert_raise FireRubyException do
+        t1 = cxn.start_transaction
+        r = ResultSet.new(cxn, t1, "select * from test", 3, nil)
+        r.fetch
+        r.close
+        t1.commit
+      end
+      cxn.close
+
+      cxn = @database.connect('user1', 'password', {Connection::SQL_ROLE_NAME => "myrole"})
+      assert_nothing_raised do
+        t1 = cxn.start_transaction
+        r = ResultSet.new(cxn, t1, "select * from test", 3, nil)
+        r.fetch
+        r.close
+        t1.commit
+      end
+      cxn.close
+   end
+end