ibruby 0.5.1-mswin32

data/test/AddRemoveUserTest.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class AddRemoveUserTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}add_remove_user_unit_test.ib"
+
+   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)
+   end
+
+   def teardown
+      # 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
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      au = AddUser.new('newuser', 'password', 'first', 'middle', 'last')
+      au.execute(sm)
+      sleep(3)
+
+      cxn = @database.connect('newuser', 'password')
+      cxn.close
+
+      ru = RemoveUser.new('newuser')
+      ru.execute(sm)
+      
+      sm.disconnect
+
+      begin
+         cxn = @database.connect('newuser', 'password')
+         cxn.close
+         assert(false, "Able to connect as supposedly removed user.")
+      rescue IBRubyException
+      end
+   end
+end

data/test/BackupRestoreTest.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class BackupRestoreTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}backup_restore_unit_test.ib"
+   BACKUP_FILE = "#{CURDIR}#{File::SEPARATOR}database.ibak"
+
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      # Remove existing database files.
+      if File.exist?(DB_FILE)
+         db = Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+      if File.exist?(BACKUP_FILE)
+         File.delete(BACKUP_FILE)
+      end
+
+      # Create and populate the database files.
+      @database = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('create table test(id integer)')
+         cxn.execute_immediate('insert into test values (1000)')
+         cxn.execute_immediate('insert into test values (2000)')
+         cxn.execute_immediate('insert into test values (NULL)')
+         cxn.execute_immediate('insert into test values (3000)')
+         cxn.execute_immediate('insert into test values (4000)')
+      end
+   end
+
+   def teardown
+      # Remove existing database files.
+      if File.exist?(DB_FILE)
+         db = Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+      if File.exist?(BACKUP_FILE)
+         File.delete(BACKUP_FILE)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+
+   def test01
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      b = Backup.new(DB_FILE, BACKUP_FILE)
+      b.execute(sm)
+
+      assert(File.exist?(BACKUP_FILE))
+      @database.drop(DB_USER_NAME, DB_PASSWORD)
+      assert(File.exists?(DB_FILE) == false)
+
+      r = Restore.new(BACKUP_FILE, DB_FILE)
+      r.execute(sm)
+      sm.disconnect
+
+      assert(File.exist?(DB_FILE))
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         total = 0
+         cxn.execute_immediate('select * from test') do |row|
+            assert([1000, 2000, 3000, 4000, nil].include?(row[0]))
+            total += 1
+         end
+         assert(total == 5)
+      end
+   end
+
+   def test02
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      b = Backup.new(DB_FILE, BACKUP_FILE)
+      b.metadata_only = true
+      b.execute(sm)
+
+      assert(File.exist?(BACKUP_FILE))
+      @database.drop(DB_USER_NAME, DB_PASSWORD)
+      assert(File.exists?(DB_FILE) == false)
+
+      r = Restore.new(BACKUP_FILE, DB_FILE)
+      r.execute(sm)
+      sm.disconnect
+
+      assert(File.exist?(DB_FILE))
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('select count(*) from test') do |row|
+            assert(row[0] == 0)
+         end
+      end
+   end
+end

data/test/BooleanTest.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class RowTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}boolean_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)
+      
+      @connection.start_transaction do |tx|
+         tx.execute('create table bool_types (col01 boolean)')
+      end
+    end
+
+    # test to ensure we can insert boolean data directly in
+    def test01
+      @connection.start_transaction do |tx|
+         tx.execute("delete from bool_types")
+       end
+      @connection.start_transaction do |tx|
+         tx.execute("insert into bool_types values (false)")
+         tx.execute("insert into bool_types values (true)")
+         tx.execute("insert into bool_types values (null)")
+       end
+       
+       checkBooleanValues
+    end
+    
+    def checkBooleanValues
+      sql = "select col01 from bool_types"
+      rows = @connection.execute_immediate(sql)
+      row = rows.fetch
+      assert(row != nil )
+      assert(row[0] == false)
+      row = rows.fetch
+      assert(row != nil )
+      assert(row[0] == true)
+      row = rows.fetch
+      assert(row != nil )
+      assert(row[0]==nil)
+      
+      rows.close
+    end
+    
+    #test to ensure we can insert boolean data in using 
+    def test02
+      @connection.start_transaction do |tx|
+         tx.execute("delete from bool_types")
+       end
+      @connection.start_transaction do |tx|
+         stmt = Statement.new(@connection, tx,
+                              "insert into bool_types values(?)",
+                              3)
+         
+         stmt.execute_for([false])
+         stmt.execute_for([true])
+         stmt.execute_for([nil])
+       end
+       
+       checkBooleanValues
+     end
+     
+     #ensures that non-valid string names cause exceptions to be thrown
+    def test03
+      @connection.start_transaction do |tx|
+         stmt = Statement.new(@connection, tx,
+                              "insert into bool_types values(?)",
+                              3)
+        
+         assert_raise(IBRuby::IBRubyException) do 
+           stmt.execute_for(['fred'])
+        end
+      end
+     end
+
+    # does tests for proper handling of string names for booleans (true/false)
+    def test04
+      @connection.start_transaction do |tx|
+         stmt = Statement.new(@connection, tx,
+                              "insert into bool_types values(?)",
+                              3)
+        
+	assert_nothing_raised() do 
+           assert( stmt.execute_for(['false']) == 1 )
+           assert( stmt.execute_for(['False']) == 1 )
+           assert( stmt.execute_for(['true']) == 1 )
+           assert( stmt.execute_for(['True']) == 1 )
+        end
+      end
+     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
+end

data/test/CharacterSetTest.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class CharacterSetTest < Test::Unit::TestCase
+   CURDIR   = "#{Dir.getwd}"
+   DB_FILE  = "#{CURDIR}#{File::SEPARATOR}cxnarset_unit_test.ib"
+   CHAR_SET = 'WIN1251'
+   
+   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, 1024,
+                                  CHAR_SET)
+   end
+   
+   def teardown
+      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
+      db = Database.new(DB_FILE, CHAR_SET)
+
+      assert(db.character_set = CHAR_SET)
+
+      db.character_set = 'ASCII'
+      assert(db.character_set == 'ASCII')
+   end
+
+   def test02
+      text = "�?����"
+      db   = Database.new(DB_FILE, CHAR_SET)
+
+      begin
+         db.connect("SYSDBA", "masterkey") do |cxn|
+            cxn.start_transaction do |tr|
+               cxn.execute("CREATE TABLE SAMPLE_TABLE(SAMPLE_FIELD VARCHAR(100))",tr)
+            end  
+            cxn.start_transaction do |tr|
+               cxn.execute("INSERT INTO SAMPLE_TABLE VALUES ('#{win1251_str}')",tr)
+               cxn.execute("SELECT * FROM SAMPLE_TABLE WHERE SAMPLE_FIELD = "\
+                           "'#{win1251_str}'",tr) do |row|
+                  # here we have an exception:
+                  some_var = row['SAMPLE_FIELD']
+               end
+            end
+         end
+      rescue => error
+         assert("Character set unit test failure.", false)
+      end
+   end
+end

data/test/ConnectionTest.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class ConnectionTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}con_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 = []
+   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
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   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 == 113) # interbase has 113 field types for a newly created database vs firebird's 88
+      tx.commit
+
+      total = 0      
+      @connections[0].execute_immediate("SELECT RDB$FIELD_NAME FROM RDB$FIELDS") do |row|
+         total = total + 1
+      end
+      assert(total == 113)
+   end
+
+   def test04
+      connection = @database.connect(DB_USER_NAME, DB_PASSWORD)
+
+      tx1 = connection.start_transaction
+      tx2 = connection.start_transaction
+      tx3 = connection.start_transaction
+
+      tx2.rollback
+      assert(tx2.active? == false)
+
+      connection.close
+
+      assert(connection.closed?)
+      assert(tx1.active? == false)
+      assert(tx3.active? == false)
+   end
+end

data/test/DDLTest.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class DDLTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}ddl_unit_test.ibb"
+   
+   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)
+   end
+   
+   def teardown
+      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
+      @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 NUMERIC(18,0), FIELD04 TIMESTAMP '\
+                               'NOT NULL, FIELD05 VARCHAR(600))')
+
+         cxn.start_transaction do |tx|
+            r = tx.execute('SELECT COUNT(*) FROM DDL_TABLE_01')
+            assert(r.fetch[0] == 0)
+            r.close
+         end
+         
+         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,83 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class DatabaseTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}db_unit_test.ibb"
+   CREATE_FILE = "#{CURDIR}#{File::SEPARATOR}db_create_test.ibb"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      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
+      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 'ibruby'
+
+include IBRuby
+
+class GeneratorTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}generator_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  = []
+      
+      @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