fireruby 0.4.1-mswin32 → 0.4.2-mswin32

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

data/test/RowCountTest.rb

@@ -1,65 +1,65 @@
-#!/usr/bin/env ruby
-
-require 'TestSetup'
-require 'test/unit'
-require 'rubygems'
-require 'fireruby'
-
-include FireRuby
-
-class RowCountTest < Test::Unit::TestCase
-   CURDIR      = "#{Dir.getwd}"
-   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}row_count_test.fdb"
-
-   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
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class RowCountTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}row_count_test.fdb"
+
+   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

data/test/RowTest.rb

@@ -1,203 +1,203 @@
-#!/usr/bin/env ruby
-
-require 'TestSetup'
-require 'test/unit'
-require 'rubygems'
-require 'fireruby'
-
-include FireRuby
-
-class RowTest < Test::Unit::TestCase
-   CURDIR  = "#{Dir.getwd}"
-   DB_FILE = "#{CURDIR}#{File::SEPARATOR}row_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)
-      @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, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
-                      [0, SQLType::INTEGER], [0, SQLType::INTEGER]]
-      
-      @connection.start_transaction do |tx|
-         tx.execute('create table rowtest (COL01 integer, COL02 varchar(10), '\
-                    'COL03 integer)')
-         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
-      @connection.start_transaction do |tx|
-         tx.execute("insert into rowtest values (1, 'Two', 3)")
-         
-         stmt = Statement.new(@connection, tx,
-                              "insert into all_types values(?, ?, ?, ?, ?, ?, "\
-                              "?, ?, ?, ?, ?, ?, ?)",
-                              3)
-         #stmt.execute_for([nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil])
-         stmt.execute_for([100000, nil, 'La la la', Date.new(2005, 10, 29),
-                           10.23, 100.751, 56.25, 12345, 19863.21, 123,
-                           Time.new, Time.new, 'The End!'])
-      end
-   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
-      puts "#{self.class.name} finished." if TEST_LOGGING
-   end
-   
-   def test01
-      row = Row.new(@results, @empty, 100)
-      
-      assert(row.column_count == 28)
-      assert(row.number == 100)
-      assert(row.column_name(0) == 'RDB$FIELD_NAME')
-      assert(row.column_alias(10) == 'RDB$FIELD_TYPE')
-      assert(row[0] == 0)
-      assert(row['RDB$FIELD_TYPE'] == 0)
-   end
-   
-   def test02
-      sql  = 'select COL01 one, COL02 two, COL03 three from rowtest'
-      rows = @connection.execute_immediate(sql)
-      data = rows.fetch
-      
-      count = 0
-      data.each do |name, value|
-         assert(['ONE', 'TWO', 'THREE'].include?(name))
-         assert([1, 'Two', 3].include?(value))
-         count += 1
-      end
-      assert(count == 3)
-      
-      count = 0
-      data.each_key do |name|
-         assert(['ONE', 'TWO', 'THREE'].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('TWO') == 'Two')
-      assert(data.fetch('FOUR', 'LALALA') == 'LALALA')
-      assert(data.fetch('ZERO') {'NOT FOUND'} == 'NOT FOUND')
-      begin
-         data.fetch('FIVE')
-         assert(false, 'Row#fetch succeeded for non-existent column name.')
-      rescue IndexError
-      end
-      
-      assert(data.has_key?('ONE'))
-      assert(data.has_key?('TEN') == 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(['ONE', 'TWO', 'THREE'].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 == 'TWO'}
-      assert(array.size == 1)
-      assert(array[0][0] == 'TWO')
-      assert(array[0][1] == 'Two')
-      
-      array = data.to_a
-      assert(array.size == 3)
-      assert(array.include?(['ONE', 1]))
-      assert(array.include?(['TWO', 'Two']))
-      assert(array.include?(['THREE', 3]))
-      
-      hash = data.to_hash
-      assert(hash.length == 3)
-      assert(hash['ONE'] == 1)
-      assert(hash['TWO'] == 'Two')
-      assert(hash['THREE'] == 3)
-      
-      array = data.values_at('TEN', 'TWO', 'THREE')
-      assert(array.size == 3)
-      assert(array.include?('Two'))
-      assert(array.include?(3))
-      assert(array.include?(nil))
-      
-      rows.close
-   end
-   
-   def test03
-      results = nil
-      row     = nil
-      
-      begin
-         results = @connection.execute_immediate('select * from all_types')
-         row     = results.fetch
-         
-         assert(row.get_base_type(0) == SQLType::BIGINT)
-         assert(row.get_base_type(1) == SQLType::BLOB)
-         assert(row.get_base_type(2) == SQLType::CHAR)
-         assert(row.get_base_type(3) == SQLType::DATE)
-         assert(row.get_base_type(4) == SQLType::DECIMAL)
-         assert(row.get_base_type(5) == SQLType::DOUBLE)
-         assert(row.get_base_type(6) == SQLType::FLOAT)
-         assert(row.get_base_type(7) == SQLType::INTEGER)
-         assert(row.get_base_type(8) == SQLType::NUMERIC)
-         assert(row.get_base_type(9) == SQLType::SMALLINT)
-         assert(row.get_base_type(10) == SQLType::TIME)
-         assert(row.get_base_type(11) == SQLType::TIMESTAMP)
-         assert(row.get_base_type(12) == SQLType::VARCHAR)
-      ensure
-         results.close if results != nil
-      end
-   end
-end
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class RowTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}row_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)
+      @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, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER]]
+      
+      @connection.start_transaction do |tx|
+         tx.execute('create table rowtest (COL01 integer, COL02 varchar(10), '\
+                    'COL03 integer)')
+         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
+      @connection.start_transaction do |tx|
+         tx.execute("insert into rowtest values (1, 'Two', 3)")
+         
+         stmt = Statement.new(@connection, tx,
+                              "insert into all_types values(?, ?, ?, ?, ?, ?, "\
+                              "?, ?, ?, ?, ?, ?, ?)",
+                              3)
+         #stmt.execute_for([nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil])
+         stmt.execute_for([100000, nil, 'La la la', Date.new(2005, 10, 29),
+                           10.23, 100.751, 56.25, 12345, 19863.21, 123,
+                           Time.new, Time.new, 'The End!'])
+      end
+   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
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test01
+      row = Row.new(@results, @empty, 100)
+      
+      assert(row.column_count == 28)
+      assert(row.number == 100)
+      assert(row.column_name(0) == 'RDB$FIELD_NAME')
+      assert(row.column_alias(10) == 'RDB$FIELD_TYPE')
+      assert(row[0] == 0)
+      assert(row['RDB$FIELD_TYPE'] == 0)
+   end
+   
+   def test02
+      sql  = 'select COL01 one, COL02 two, COL03 three from rowtest'
+      rows = @connection.execute_immediate(sql)
+      data = rows.fetch
+      
+      count = 0
+      data.each do |name, value|
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
+         assert([1, 'Two', 3].include?(value))
+         count += 1
+      end
+      assert(count == 3)
+      
+      count = 0
+      data.each_key do |name|
+         assert(['ONE', 'TWO', 'THREE'].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('TWO') == 'Two')
+      assert(data.fetch('FOUR', 'LALALA') == 'LALALA')
+      assert(data.fetch('ZERO') {'NOT FOUND'} == 'NOT FOUND')
+      begin
+         data.fetch('FIVE')
+         assert(false, 'Row#fetch succeeded for non-existent column name.')
+      rescue IndexError
+      end
+      
+      assert(data.has_key?('ONE'))
+      assert(data.has_key?('TEN') == 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(['ONE', 'TWO', 'THREE'].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 == 'TWO'}
+      assert(array.size == 1)
+      assert(array[0][0] == 'TWO')
+      assert(array[0][1] == 'Two')
+      
+      array = data.to_a
+      assert(array.size == 3)
+      assert(array.include?(['ONE', 1]))
+      assert(array.include?(['TWO', 'Two']))
+      assert(array.include?(['THREE', 3]))
+      
+      hash = data.to_hash
+      assert(hash.length == 3)
+      assert(hash['ONE'] == 1)
+      assert(hash['TWO'] == 'Two')
+      assert(hash['THREE'] == 3)
+      
+      array = data.values_at('TEN', 'TWO', 'THREE')
+      assert(array.size == 3)
+      assert(array.include?('Two'))
+      assert(array.include?(3))
+      assert(array.include?(nil))
+      
+      rows.close
+   end
+   
+   def test03
+      results = nil
+      row     = nil
+      
+      begin
+         results = @connection.execute_immediate('select * from all_types')
+         row     = results.fetch
+         
+         assert(row.get_base_type(0) == SQLType::BIGINT)
+         assert(row.get_base_type(1) == SQLType::BLOB)
+         assert(row.get_base_type(2) == SQLType::CHAR)
+         assert(row.get_base_type(3) == SQLType::DATE)
+         assert(row.get_base_type(4) == SQLType::DECIMAL)
+         assert(row.get_base_type(5) == SQLType::DOUBLE)
+         assert(row.get_base_type(6) == SQLType::FLOAT)
+         assert(row.get_base_type(7) == SQLType::INTEGER)
+         assert(row.get_base_type(8) == SQLType::NUMERIC)
+         assert(row.get_base_type(9) == SQLType::SMALLINT)
+         assert(row.get_base_type(10) == SQLType::TIME)
+         assert(row.get_base_type(11) == SQLType::TIMESTAMP)
+         assert(row.get_base_type(12) == SQLType::VARCHAR)
+      ensure
+         results.close if results != nil
+      end
+   end
+end