fireruby 0.2.2-i586-linux

data/test/ConnectionTest.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem '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)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      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)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+   end
+   
+   def test01
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      
+      assert(@connections[0].user == DB_USER_NAME)
+      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].user == DB_USER_NAME)
+      assert(@connections[0].open? == false)
+      assert(@connections[0].closed?)
+      assert(@connections[0].database == @database)
+      assert(@connections[0].to_s == "(CLOSED)")
+      
+      @connections[0] = @database.connect(DB_USER_NAME, DB_PASSWORD)
+      assert(@connections[0].open?)
+      @connections.push(Connection.new(@database, DB_USER_NAME, DB_PASSWORD))
+      assert(@connections[0].open?)
+      assert(@connections[1].open?)
+   end
+   
+   def test02
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      
+      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(DB_USER_NAME, DB_PASSWORD))
+      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,50 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem '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_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      @database = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+   end
+   
+   def teardown
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+   end
+   
+   def test01
+      @database.connect(DB_USER_NAME, DB_PASSWORD) 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] == 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,81 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem '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_FILE)
+         db.drop
+      end
+      if File.exist?(CREATE_FILE)
+         db = Database.new(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_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
+   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,48 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem '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(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
+   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,97 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem '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_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @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))")
+      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
+   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 == Row)
+      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/RowTest.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem 'fireruby'
+
+include FireRuby
+
+class RowTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}row_unit_test.fdb"
+   
+   def setup
+      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, 1024, nil)
+      @connection  = database.connect(DB_USER_NAME, DB_PASSWORD)
+      @transaction = @connection.start_transaction
+      @statement   = Statement.new(@connection, @transaction,
+                                   'SELECT * FROM RDB$FIELDS', 3)
+      @results     = ResultSet.new(@statement)
+      @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]
+   end
+   
+   def teardown
+      @results.close
+      @statement.close
+      @transaction.rollback
+      @connection.close
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+   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
+end

data/test/SQLTest.rb

@@ -0,0 +1,171 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem '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_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD,
+                                       1024, 'ASCII')
+      @connections  = []
+      @transactions = []
+      
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('CREATE TABLE TEST_TABLE (TESTID INTEGER '\
+                               'NOT NULL PRIMARY KEY, TESTTEXT VARCHAR(100), '\
+                               'TESTFLOAT NUMERIC(8,2), 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_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+   end
+   
+   def test01
+      @database.connect(DB_USER_NAME, DB_PASSWORD) 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(DB_USER_NAME, DB_PASSWORD))
+      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(DB_USER_NAME, DB_PASSWORD) 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(DB_USER_NAME, DB_PASSWORD))
+      @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[0] == 2)
+      assert(a[1] == '3.0')
+      assert(a[2] == 3.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 4)
+      assert(a[1] == '10.0')
+      assert(a[2] == 10.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 6)
+      assert(a[1] == '21.0')
+      assert(a[2] == 21.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 8)
+      assert(a[1] == '36.0')
+      assert(a[2] == 36.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 10)
+      assert(a[1] == '55.0')
+      assert(a[2] == 55.0)
+      assert(a[3] == nil)
+      assert(a[4] == 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 = []
+      t = nil
+      @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
+      end
+      assert(a[0] == 'La la la')
+      assert(a[1] == 3.14)
+      assert(a[2].to_i == t.to_i)
+      
+      @connections[0].execute_immediate("DELETE FROM TEST_TABLE WHERE TESTID "\
+                                        "IN (1, 3, 5, 7, 9, 12, 14, 16, 18, 20)")
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         r = cxn.execute_immediate("SELECT COUNT(*) FROM TEST_TABLE")
+         a = r.fetch
+         r.close
+         assert(a[0] == 11)
+      end
+   end
+end
+