fireruby 0.1.0-powerpc-darwin

data/test/CVS/Entries

@@ -0,0 +1,17 @@
+/.gdb_history/1.1.1.1/Tue Mar 15 10:36:35 2005//
+/ConnectionTest.rb/1.1.1.1/Tue Mar 15 10:36:35 2005//
+/DDLTest.rb/1.1.1.1/Tue Mar 15 10:36:35 2005//
+/DatabaseTest.rb/1.1.1.1/Tue Mar 15 10:36:35 2005//
+/GeneratorTest.rb/1.1.1.1/Tue Mar 15 10:36:35 2005//
+/ResultSetTest.rb/1.1.1.1/Tue Mar 15 10:36:36 2005//
+/SQLTest.rb/1.1.1.1/Tue Mar 15 10:36:45 2005//
+/StatementTest.rb/1.1.1.1/Tue Mar 15 10:36:45 2005//
+/TestSetup.rb/1.1.1.1/Tue Mar 15 10:37:07 2005//
+/TransactionTest.rb/1.1.1.1/Tue Mar 15 10:37:07 2005//
+/UnitTest.rb/1.1.1.1/Tue Mar 15 10:37:07 2005//
+/example.c/1.1.1.1/Tue Mar 15 10:36:35 2005//
+/fb.c/1.1.1.1/Tue Mar 15 10:36:35 2005//
+/mfb/1.1.1.1/Tue Mar 15 10:36:35 2005//
+/sql_unit_test.fdb/1.1.1.1/Tue Mar 15 10:36:45 2005//
+/test.fdb/1.1.1.1/Tue Mar 15 10:37:07 2005//
+D

data/test/CVS/Repository

@@ -0,0 +1 @@
+/var/cvs/fireruby/fireruby/test

data/test/CVS/Root

@@ -0,0 +1 @@
+:ext:paw220470@rubyforge.org:/var/cvs/fireruby

data/test/ConnectionTest.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'fireruby'
+
+include FireRuby
+
+class ConnectionTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}con_unit_test.fdb"
+   
+   def setup
+      if File::exist?(DB_FILE)
+         db = Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE)
+         db.drop
+      end
+
+      @database    = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @connections = []
+   end
+   
+   def teardown
+      @connections.each {|connection| connection.close}
+      @connections.clear
+
+      if File::exist?(DB_FILE)
+         db = Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE)
+         db.drop
+      end
+   end
+   
+   def test01
+      @connections.push(@database.connect)
+      
+      assert(@connections[0].open?)
+      assert(@connections[0].closed? == false)
+      assert(@connections[0].database == @database)
+      assert(@connections[0].to_s == "#{DB_USER_NAME}@#{DB_FILE} (OPEN)")
+      
+      @connections[0].close
+      assert(@connections[0].open? == false)
+      assert(@connections[0].closed?)
+      assert(@connections[0].database == @database)
+      assert(@connections[0].to_s == "(CLOSED)")
+      
+      @connections[0] = @database.connect
+      assert(@connections[0].open?)
+      @connections.push(Connection.new(@database))
+      assert(@connections[0].open?)
+      assert(@connections[1].open?)
+   end
+   
+   def test02
+      @connections.push(@database.connect)
+      
+      tx = @connections[0].start_transaction
+      assert(tx != nil)
+      assert(tx.class == Transaction)
+      assert(tx.active?)
+      tx.rollback
+      
+      tx = nil
+      @connections[0].start_transaction do |transaction|
+         assert(transaction != nil)
+         assert(transaction.class == Transaction)
+         assert(transaction.active?)
+         tx = transaction
+      end
+      assert(tx != nil)
+      assert(tx.class == Transaction)
+      assert(tx.active? == false)
+   end
+   
+   def test03
+      @connections.push(@database.connect)
+      tx    = @connections[0].start_transaction
+      total = 0
+      @connections[0].execute("SELECT RDB$FIELD_NAME FROM RDB$FIELDS", tx) do |row|
+         total = total + 1
+      end
+      assert(total == 88)
+      tx.commit
+
+      total = 0      
+      @connections[0].execute_immediate("SELECT RDB$FIELD_NAME FROM RDB$FIELDS") do |row|
+         total = total + 1
+      end
+      assert(total == 88)
+   end
+end

data/test/DDLTest.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'fireruby'
+
+include FireRuby
+
+class DDLTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}ddl_unit_test.fdb"
+   
+   def setup
+      if File::exist?(DB_FILE)
+         Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE).drop
+      end
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+   end
+   
+   def teardown
+      if File::exist?(DB_FILE)
+         Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE).drop
+      end
+   end
+   
+   def test01
+      @database.connect do |cxn|
+         cxn.execute_immediate('CREATE TABLE DDL_TABLE_01 (TABLEID '\
+                               'INTEGER NOT NULL, '\
+                               'FIELD01 FLOAT, FIELD02 CHAR(50), '\
+                               'FIELD03 BIGINT, FIELD04 TIMESTAMP '\
+                               'NOT NULL, FIELD05 VARCHAR(600))')
+
+         r = cxn.execute_immediate('SELECT COUNT(*) FROM DDL_TABLE_01')
+         assert(r.fetch == [0])
+         r.close
+         
+         cxn.execute_immediate('ALTER TABLE DDL_TABLE_01 ADD PRIMARY KEY '\
+                               '(TABLEID)')
+                               
+         cxn.execute_immediate('CREATE UNIQUE INDEX DDL_TABLE_IDX ON '\
+                               'DDL_TABLE_01 (TABLEID)')
+                               
+         cxn.execute_immediate('DROP INDEX DDL_TABLE_IDX')
+         
+         cxn.execute_immediate('DROP TABLE DDL_TABLE_01')
+      end
+   end
+end

data/test/DatabaseTest.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+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
+      if File.exist?(DB_FILE)
+         db = Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE)
+         db.drop
+      end
+      if File.exist?(CREATE_FILE)
+         db = Database.new(DB_USER_NAME, DB_PASSWORD, CREATE_FILE)
+         db.drop
+      end
+      
+      Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, 'ASCII')
+   end
+   
+   def teardown
+      if File::exist?(DB_FILE)
+         db = Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE)
+         db.drop
+      end
+      if File::exist?(CREATE_FILE)
+         db = Database.new(DB_USER_NAME, DB_PASSWORD, CREATE_FILE)
+         db.drop
+      end
+   end
+   
+   
+   def test01
+      puts "Executing test01.\n\n"
+      db = Database.create(CREATE_FILE, DB_USER_NAME, DB_PASSWORD, 2048, 'ASCII')
+      
+      assert(File.exist?(CREATE_FILE))
+      assert(db.user == DB_USER_NAME)
+      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
+      assert(File.exist?(CREATE_FILE) == false)
+   end
+   
+   def test02
+      puts "Executing test02.\n\n"
+      db = Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE);
+      
+      assert(db.user == DB_USER_NAME)
+      assert(db.file == DB_FILE)
+      
+      c = db.connect
+      assert(c != nil)
+      c.close
+   end
+   
+   def test03
+      db = Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE);
+      c  = nil
+
+      db.connect 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,47 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'fireruby'
+
+include FireRuby
+
+class GeneratorTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}generator_unit_test.fdb"
+   
+   def setup
+      if File::exist?(DB_FILE)
+         Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE).drop
+      end
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @connections  = []
+      
+      @connections.push(@database.connect)
+   end
+   
+   def teardown
+      @connections.each do |cxn|
+         cxn.close if cxn.open?
+      end
+      @connections.clear
+      if File::exist?(DB_FILE)
+         Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE).drop
+      end
+   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/ResultSetTest.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'fireruby'
+
+include FireRuby
+
+class ResultSetTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}result_set_unit_test.fdb"
+   
+   def setup
+      if File::exist?(DB_FILE)
+         Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE).drop
+      end
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @connections  = []
+      @transactions = []
+      
+      @connections.push(@database.connect)
+      
+      @connections[0].start_transaction do |tx|
+         tx.execute("CREATE TABLE TEST_TABLE (TESTID INTEGER NOT NULL "\
+                    "primary KEY, TESTINFO VARCHAR(100))")
+      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_USER_NAME, DB_PASSWORD, DB_FILE).drop
+      end
+   end
+   
+   def test01
+      s = Statement.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3)
+      
+      r = ResultSet.new(s)
+      
+      assert(r.statement == s)
+      
+      assert(r.fetch != nil)
+      assert(r.fetch.class == Array)
+      assert(r.fetch[0] == 30)
+      assert(r.fetch[1] == 'Record Four.')
+      r.fetch
+      assert(r.fetch == nil)
+      
+      r = ResultSet.new(s)
+      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 = ResultSet.new(s)
+      total = 0
+      r.each do |row|
+         total += 1
+      end
+      assert(total == 5)
+   end
+end

data/test/SQLTest.rb

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'fireruby'
+
+include FireRuby
+
+class SQLTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}sql_unit_test.fdb"
+   ITERATIONS  = 100
+   
+   INSERT_SQL  = "INSERT INTO TEST_TABLE VALUES(?, ?, ?, ?, ?, ?)"
+   
+   def setup
+      if File::exist?(DB_FILE)
+         Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE).drop
+      end
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD,
+                                       1024, 'ASCII')
+      @connections  = []
+      @transactions = []
+      
+      @database.connect do |cxn|
+         cxn.execute_immediate('CREATE TABLE TEST_TABLE (TESTID INTEGER '\
+                               'NOT NULL PRIMARY KEY, TESTTEXT VARCHAR(100), '\
+                               'TESTFLOAT FLOAT, TESTDATE DATE, TESTTIME '\
+                               'TIME, TESTSTAMP TIMESTAMP)')
+      end
+   end
+   
+   def teardown
+      @transactions.each do |tx|
+         tx.rollback if tx.active?
+      end
+      
+      @connections.each do |cxn|
+         cxn.close if cxn.open?
+      end
+      
+      #if File::exist?(DB_FILE)
+      #   Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE).drop
+      #end
+   end
+   
+   def test01
+      @database.connect do |cxn|
+         cxn.start_transaction do |tx|
+            s = Statement.new(cxn, tx, INSERT_SQL, 3)
+            f = 0.0
+            t = Time.new
+            
+            1.upto(ITERATIONS) do |i|
+               f += 0.321
+               t = Time.at(t.to_i + 5)
+               s.execute_for([i, i.to_s, f, t, nil, t])
+            end
+         end
+      end
+      
+      @connections.push(@database.connect)
+      r = @connections[0].execute_immediate("SELECT COUNT(*) FROM TEST_TABLE")
+      assert(r.fetch[0] == ITERATIONS)
+      r.close
+   end
+   
+   def test02
+      f = 0.0
+      @database.connect do |cxn|
+         1.upto(20) do |i|
+            f += i
+            sql = "INSERT INTO TEST_TABLE VALUES (#{i}, "\
+                  "#{f.to_s}, #{f}, NULL, NULL, 'NOW')"
+            cxn.execute_immediate(sql)
+         end
+      end
+      
+      @connections.push(@database.connect)
+      @transactions.push(@connections[0].start_transaction)
+      r = @transactions[0].execute("SELECT COUNT(*) FROM TEST_TABLE")
+      assert(r.fetch[0] == 20)
+      r.close
+      
+      r = @transactions[0].execute("SELECT * FROM TEST_TABLE WHERE TESTID IN "\
+                                   "(2, 4, 6, 8, 10) ORDER BY TESTID ASCENDING")
+      a = r.fetch
+      assert(a.delete_at(5) != nil)
+      assert(a == [2, '3.0', 3.0, nil, nil])
+
+      a = r.fetch
+      assert(a.delete_at(5) != nil)
+      assert(a == [4, '10.0', 10.0, nil, nil])
+
+      a = r.fetch
+      assert(a.delete_at(5) != nil)
+      assert(a == [6, '21.0', 21.0, nil, nil])
+
+      a = r.fetch
+      assert(a.delete_at(5) != nil)
+      assert(a == [8, '36.0', 36.0, nil, nil])
+
+      a = r.fetch
+      assert(a.delete_at(5) != nil)
+      assert(a == [10, '55.0', 55.0, nil, nil])
+      
+      r.close
+      
+      @transactions[0].commit
+      
+      @connections[0].start_transaction do |tx|
+         s = Statement.new(@connections[0], tx,
+                           "UPDATE TEST_TABLE SET TESTSTAMP = NULL", 3)
+         s.execute()
+         
+         r = tx.execute("SELECT TESTSTAMP FROM TEST_TABLE")
+         total = 0
+         r.each do |row|
+            assert(row[0] == nil)
+            total = total + 1
+         end
+         assert(total == 20)
+      end
+      
+      a = []
+      @connections[0].start_transaction do |tx|
+         # Perform an insert via a parameterized statement.
+         s = Statement.new(@connections[0], tx,
+                           "INSERT INTO TEST_TABLE (TESTID, TESTTEXT, "\
+                           "TESTFLOAT, TESTSTAMP) VALUES(?, ?, ?, ?)", 3)
+         t = Time.new
+         s.execute_for([25000, 'La la la', 3.14, t])
+         
+         # Fetch the record and check the data.
+         r = tx.execute("SELECT TESTTEXT, TESTFLOAT, TESTSTAMP FROM "\
+                        "TEST_TABLE WHERE TESTID = 25000")
+         a = r.fetch
+         r.close
+         puts ['La la la', 3.14, t].join(', ')
+         puts a.join(', ')
+      end
+      assert(a == ['La la la', 3.14, t])
+      
+      @connections[0].execute_immediate("DELETE FROM TEST_TABLE WHERE TESTID "\
+                                        "IN (1, 3, 5, 7, 9, 12, 14, 16, 18, 20)")
+      @database.connect do |cxn|
+         r = cxn.execute_immediate("SELECT COUNT(*) FROM TEST_TABLE")
+         a = r.fetch
+         r.close
+         assert(a[0] == 10)
+      end
+   end
+end
+

data/test/StatementTest.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'fireruby'
+
+include FireRuby
+
+class StatementTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}stmt_unit_test.fdb"
+   
+   def setup
+      if File::exist?(DB_FILE)
+         Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE).drop
+      end
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @connections  = []
+      @transactions = []
+   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_USER_NAME, DB_PASSWORD, DB_FILE).drop
+      end
+   end
+   
+   def test01
+      @connections.push(@database.connect)
+      @transactions.push(@connections.last.start_transaction)
+      
+      s1 = Statement.new(@connections[0],
+                         @transactions[0],
+                         "SELECT RDB$FIELD_NAME FROM RDB$FIELDS", 3)
+      assert(s1 != nil)
+      assert(s1.sql == "SELECT RDB$FIELD_NAME FROM RDB$FIELDS")
+      assert(s1.connection == @connections[0])
+      assert(s1.transaction == @transactions[0])
+      assert(s1.dialect == 3)
+      assert(s1.is_query? == true)
+      
+      s2 = Statement.new(@connections[0],
+                         @transactions[0],
+                         "DELETE FROM RDB$EXCEPTIONS", 1)
+      assert(s2 != nil)
+      assert(s2.sql == "DELETE FROM RDB$EXCEPTIONS")
+      assert(s2.connection == @connections[0])
+      assert(s2.transaction == @transactions[0])
+      assert(s2.dialect == 1)
+      assert(s2.is_query? == false)
+   end
+   
+   def test02
+      @connections.push(@database.connect)
+      @transactions.push(@connections[0].start_transaction)
+      
+      s = Statement.new(@connections[0], @transactions[0],
+                        "SELECT RDB$FIELD_NAME FROM RDB$FIELDS "\
+                        "WHERE RDB$FIELD_NAME LIKE ?", 3)
+
+      begin
+         s.execute
+         assert(false,
+                "Executed statement that required parameter without the "\
+                "parameter being specified.")
+      rescue Exception => error
+      end
+      
+      begin
+         s.execute_for([])
+         assert(false,
+                "Executed statement that required a parameter with an empty "\
+                "parameter set.")
+      rescue Exception => error
+      end
+      
+      begin
+         s.execute_for(['LALALA', 25])
+         assert(false,
+                "Executed statement that required a parameter with too many "\
+                "parameters.")
+      rescue Exception => error
+      end
+      
+      assert(s.execute_for(['LALALA']) != nil)
+      assert(s.execute_for(['LALALA']).class == ResultSet)
+      total = 0
+      s.execute_for(["%"]) do |row|
+         total = total + 1
+      end
+      assert(total = 88)
+   end
+end

data/test/TestSetup.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+# Add extra search paths.
+basedir = File::dirname(Dir.getwd)
+$:.push(basedir)
+$:.push("#{basedir}#{File::SEPARATOR}test")
+$:.push("#{basedir}#{File::SEPARATOR}lib")
+
+DB_USER_NAME = 'sysdba'
+DB_PASSWORD  = 'masterkey'