iotaz 0.1.0

data/test/ActionTest.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class ActionTest < Test::Unit::TestCase
+   def test01
+      a = Action.new('SELECT * FROM SOME_TABLE')
+      
+      assert(a.sql == 'SELECT * FROM SOME_TABLE')
+      begin
+         a.get_parameters
+         assert(false, 'Fetched parameter set from empty action.')
+      rescue IotazError
+      end
+      
+      a.add_parameters(1, 'One', 1.0)
+      a.add_parameters(2, 'Two', 2.0)
+      
+      assert(a.get_parameters == [1, 'One', 1.0])
+      assert(a.get_parameters == [2, 'Two', 2.0])
+      begin
+         a.get_parameters
+         assert(false, 'Fetched parameter set from emptied action.')
+      rescue Exception
+      end
+   end
+end

data/test/AtomTest.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+# Dummy value class for testing.
+class DummyValue
+   attr_accessor :first, :second
+   
+   def DummyValue.iotaz_meta_data
+      IotazMetaData.scan(DummyValue)
+   end
+end
+
+# Dummy database interface class for testing.
+class DummyInterface
+   def initialize
+      @actions   = 0
+      @callbacks = 0
+      @cache     = 0
+   end
+   
+   def start_transaction
+      nil
+   end
+   
+   def execute_action(entry, transaction)
+      @actions += 1
+   end
+   
+   def execute_callback(callback, transaction)
+      @callbacks += 1
+   end
+   
+   def clean_cache(items)
+      @cache += items.size
+   end
+   
+   def commit(transaction)
+   end
+   
+   def rollback(transaction)
+   end
+   
+   attr_reader :actions, :callbacks, :cache
+end
+
+class AtomTest < Test::Unit::TestCase
+   def setup
+      @objects = []
+      @actions = []
+      
+      @objects.push(DummyValue.new)
+      @objects.push(DummyValue.new)
+      @objects.push(DummyValue.new)
+      
+      @actions.push(Action.new("Action #1"))
+      @actions.push(Action.new("Action #2"))
+      @actions.push(Action.new("Action #3"))
+
+      @actions[0].add_parameters([])
+      @actions[1].add_parameters([])
+      @actions[2].add_parameters([])
+   end
+   
+   def test01
+      atom = Atom.new
+      
+      assert(atom.action_count == 0)
+      assert(atom.callback_count == 0)
+      
+      atom.add(@actions[0])
+      atom.add(@actions[1], ValueCallback.new(@objects[0], 'first', 'The SQL.'))
+      atom.add(@actions[2], ValueCallback.new(@objects[1], 'first', 'The SQL.'),
+               ValueCallback.new(@objects[2], 'second', 'The SQL.'))
+               
+      assert(atom.action_count == 3)
+      assert(atom.callback_count == 3)
+      
+      interface = DummyInterface.new
+      atom.commit(interface)
+      
+      assert(interface.actions == 3)
+      assert(interface.callbacks == 3)
+      assert(interface.cache == 0)
+   end
+end

data/test/AttributeTest.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class AttributeTest < Test::Unit::TestCase
+   def test01
+      a = Attribute.new('att01')
+      
+      assert(a.name == 'att01')
+      assert(a.type == nil)
+      assert(a.column == 'att01')
+      assert(a.accessor == 'att01')
+      assert(a.mutator == 'att01=')
+      
+      a = Attribute.new('att02', 'ATT_02')
+      
+      assert(a.name == 'att02')
+      assert(a.type == nil)
+      assert(a.column == 'ATT_02')
+      assert(a.accessor == 'att02')
+      assert(a.mutator == 'att02=')
+      
+      a = Attribute.new('att03', 'COLUMN_03', 'string')
+      
+      assert(a.name == 'att03')
+      assert(a.type == 'string')
+      assert(a.column == 'COLUMN_03')
+      assert(a.accessor == 'att03')
+      assert(a.mutator == 'att03=')
+   end
+   
+   def test02
+      a1 = Attribute.new('name')
+      a2 = Attribute.new('name')
+      a3 = Attribute.new('name', 'DIFFERENT')
+      
+      assert(a1 == a1)
+      assert(a1 == a2)
+      assert(a1 != a3)
+   end
+   
+   def test03
+      a = Attribute.new('test_value')
+      
+      a.name = 'alternative'
+      assert(a.name == 'alternative')
+      
+      a.type = 'INTEGER'
+      assert(a.type == 'INTEGER')
+      
+      a.column = 'COL_NAME'
+      assert(a.column == 'COL_NAME')
+      
+      a.accessor = 'blah'
+      assert(a.accessor = 'blah')
+      
+      a.mutator = 'blah_de_blah'
+      assert(a.mutator == 'blah_de_blah')
+   end
+end

data/test/DatabaseInterfaceFactoryTest.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'dbinfo'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class DatabaseInterfaceFactoryTest < Test::Unit::TestCase
+   def setup
+      @configurations = [{}, {}, {}]
+      
+      @configurations[1]['iotaz.database']                 = 'unknown'
+      @configurations[2]['iotaz.database']                 = 'firebird'
+      @configurations[2]['iotaz.firebird.user']            = DB_USER_NAME
+      @configurations[2]['iotaz.firebird.password']        = DB_PASSWORD
+      @configurations[2]['iotaz.firebird.database']        = './nonexistent.fdb'
+      @configurations[2]['iotaz.firebird.connections.min'] = 0
+   end
+   
+   
+   def test01
+      begin
+         DatabaseInterfaceFactory.new(@configurations[0])
+         assert(false,
+                'Able to create an interface factory without specifying a database.')
+      rescue IotazError
+      end
+      
+      begin
+         DatabaseInterfaceFactory.new(@configurations[0])
+         assert(false,
+                'Able to create an interface factory using an illegal database.')         
+      rescue IotazError
+      end
+      
+      factory = DatabaseInterfaceFactory.new(@configurations[2])
+      assert(factory.create.class == FirebirdInterface)
+   end
+end

data/test/FirebirdInterfaceTest.rb

@@ -0,0 +1,276 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'dbinfo'
+require 'rubygems'
+require_gem 'iotaz'
+require_gem 'fireruby'
+
+include Iotaz
+
+# Class for use in testing.
+class Account
+   attr_accessor :id, :number, :customer, :created, :updated
+   
+   def initialize(number, customer)
+      @number   = number
+      @customer = customer
+   end
+   
+   def Account.iotaz_meta_data
+      IotazMetaData.scan(Account)
+   end
+end
+
+class FirebirdInterfaceTest < Test::Unit::TestCase
+   DB_FILE       = './firebird_interface_test.fdb'
+   TABLE_SQL     = 'create table Account (id integer not null primary key, '\
+                   'number varchar(10) not null, customer varchar(50), '\
+                   'created timestamp not null, updated timestamp)'
+   GENERATOR_SQL = 'create generator ACCOUNT_ID_SQ'
+   
+   def setup
+      @configurations = []
+      
+      # Full and proper configuration.
+      @configurations.push({'iotaz.database'                 => 'firebird',
+                            'iotaz.firebird.user'            => DB_USER_NAME,
+                            'iotaz.firebird.password'        => DB_PASSWORD,
+                            'iotaz.firebird.database'        => DB_FILE,
+                            'iotaz.firebird.connections.min' => 0})
+
+      # Configuration without the database user name.
+      @configurations.push({'iotaz.database'                 => 'firebird',
+                            'iotaz.firebird.password'        => DB_PASSWORD,
+                            'iotaz.firebird.database'        => DB_FILE,
+                            'iotaz.firebird.connections.min' => 0})
+      
+      # Configuration without the database user password.
+      @configurations.push({'iotaz.database'                 => 'firebird',
+                            'iotaz.firebird.user'            => DB_USER_NAME,
+                            'iotaz.firebird.database'        => DB_FILE,
+                            'iotaz.firebird.connections.min' => 0})
+      
+      # Configuration without the database file specification.
+      @configurations.push({'iotaz.database'                 => 'firebird',
+                            'iotaz.firebird.user'            => DB_USER_NAME,
+                            'iotaz.firebird.password'        => DB_PASSWORD,
+                            'iotaz.firebird.connections.min' => 0})
+                            
+      if File.exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      db = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, 'ASCII')
+      db.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate(GENERATOR_SQL)
+         cxn.execute_immediate(TABLE_SQL)
+      end
+      
+      @interface = FirebirdInterface.new(@configurations[0])
+   end
+   
+   def teardown
+      @interface.shutdown
+      if File.exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+   end
+   
+   # Test the constructor.
+   def test01
+      FirebirdInterface.new(@configurations[0])
+
+      begin
+         FirebirdInterface.new(@configurations[1])
+         assert(false,
+                'Able to successful create an interface with a database user.')
+      rescue IotazError
+      end
+
+      begin
+         FirebirdInterface.new(@configurations[2])
+         assert(false,
+                'Able to successful create an interface with a database password.')
+      rescue IotazError
+      end
+
+      begin
+         FirebirdInterface.new(@configurations[3])
+         assert(false,
+                'Able to successful create an interface with a database file.')
+      rescue IotazError
+      end
+   end
+   
+   # Test the transactional elements.
+   def test02
+      transaction = @interface.start_transaction
+      
+      assert(transaction.class == Array)
+      assert(transaction.size == 2)
+      assert(transaction[0].class == FireRuby::Connection)
+      assert(transaction[1] == nil)
+      
+      @interface.commit(transaction)
+      assert(transaction[0] == nil)
+      assert(transaction[1] == nil)
+      
+      transaction = @interface.start_transaction
+      assert(transaction[0].class == FireRuby::Connection)
+      assert(transaction[1] == nil)
+      
+      @interface.rollback(transaction)
+      assert(transaction[0] == nil)
+      assert(transaction[1] == nil)
+   end
+   
+   # Tes the SQL generation code.
+   def test03
+      account = Account.new('ACC001', 'The Customer')
+      
+      # Check SQL for inserts.
+      sql, callbacks, parameters = @interface.get_insert_sql(account)
+      
+      assert(/^insert into Account\(/.match(sql) != nil)
+      assert(sql.include?(' values('))
+      index  = sql.index(' values(') + 1
+      insert = sql[0, index]
+      values = sql[index, sql.length - insert.length]
+      assert(/[ (]id/.match(insert) != nil)
+      assert(/[ (]number/.match(insert) != nil)
+      assert(/[ (]customer/.match(insert) != nil)
+      assert(/[ (]created/.match(insert) != nil)
+      assert(values.count('?') == 3)
+      assert(/'NOW'/.match(values) != nil)
+      
+      assert(callbacks.size == 1)
+      assert(callbacks[0].sql == 'select created from Account where id = ?')
+      assert(parameters.size == 3)
+      assert(parameters.include?(account.id))
+      assert(parameters.include?('ACC001'))
+      assert(parameters.include?('The Customer'))
+      
+      # Check SQL for updates.
+      sql, callbacks, parameters = @interface.get_update_sql(account)
+      
+      assert(/^update Account set /.match(sql) != nil)
+      assert(sql.include?('number = ?'))
+      assert(sql.include?('customer = ?'))
+      assert(sql.include?("updated = 'NOW'"))
+      assert(/where id = \?$/.match(sql) != nil)
+      
+      assert(callbacks.size == 1)
+      assert(callbacks[0].sql == 'select updated from Account where id = ?')
+      assert(parameters.size == 3)
+      assert(parameters.include?(account.id))
+      assert(parameters.include?('ACC001'))
+      assert(parameters.include?('The Customer'))
+      
+      # Check the SQL for fetches.
+      sql = @interface.get_fetch_sql(Account)
+      
+      index  = sql.index(' where ') + 1
+      select = sql[0, index]
+      where  = sql[index, sql.length - select.length]
+      assert(select.include?('id'))
+      assert(select.include?('number'))
+      assert(select.include?('customer'))
+      assert(select.include?('created'))
+      assert(select.include?('updated'))
+      assert(where == 'where id = ?')
+      
+      # Check SQL for deletes.
+      sql = @interface.get_delete_sql(account)
+      
+      assert(sql == 'delete from Account where id = ?')
+   end
+   
+   
+   # Test the execute methods.
+   def test04
+      # Test the FirebirdInterface#execute_action method.
+      sql         = "insert into account values(?, ?, ?, 'NOW', null)"
+      action      = Action.new(sql)
+      action.add_parameters(2500, 'ACC002', 'Customer Name')
+      transaction = @interface.start_transaction
+      begin
+         @interface.execute_action(action, transaction)
+
+         select = 'select count(*) from account where id = 2500'
+         d = transaction[1].execute(select)
+         r = d.fetch
+         d.close
+         assert(r[0] == 1)
+         
+         @interface.commit(transaction)
+      rescue Exception => error
+         @interface.rollback(transaction)
+         raise error
+      end
+      
+      # Test the FirebirdInterface#execute_callback method.
+      sql         = 'select created from account where id = ?'
+      account     = Account.new('ACC002', 'Customer Name')
+      callback    = ValueCallback.new(account, 'created', sql)
+      account.id  = 2500
+      transaction = @interface.start_transaction
+      begin
+         data = @interface.execute_callback(callback, transaction)
+         assert(data != nil)
+         assert(data.class == Time)
+         
+         @interface.commit(transaction)
+      rescue Exception => error
+         @interface.rollback(transaction)
+         raise error
+      end
+      
+      # Test the FirebirdInterface#execute_select method.
+      sql   = 'select * from account'
+      transaction = @interface.start_transaction
+      begin
+         array = @interface.execute_select(sql, [], transaction)
+         
+         assert(array != nil)
+         assert(array.class == Array)
+         assert(array.size == 1)
+         assert(array[0]['ID'] == 2500)
+         assert(array[0]['NUMBER'] == 'ACC002')
+         assert(array[0]['CUSTOMER'] == 'Customer Name')
+         assert(array[0]['CREATED'].class == Time)
+         assert(array[0]['UPDATED'] == nil)
+         
+         @interface.commit(transaction)
+      rescue Exception => error
+         @interface.rollback(transaction)
+         raise error
+      end
+      
+      # Test the FirebirdInterface#execute_query method.
+      query = Query.new(Account)
+      query.field('number').equal_to('ACC002')
+      transaction = @interface.start_transaction
+      begin
+         rows = @interface.execute_query(query, transaction)
+         
+         assert(rows != nil)
+         assert(rows[0].class == QueryRow)
+         assert(rows.size == 1)
+         assert(rows[0]['ID'] == 2500)
+         assert(rows[0]['NUMBER'] == 'ACC002')
+         assert(rows[0]['CUSTOMER'] == 'Customer Name')
+         assert(rows[0]['CREATED'].class == Time)
+         assert(rows[0]['UPDATED'] == nil)
+         
+         @interface.commit(transaction)
+      rescue Exception => error
+         @interface.rollback(transaction)
+         raise error
+      end
+   end
+   
+   # Test miscellaneous methods.
+   def test05
+      assert(@interface.get_sequence_value('ACCOUNT_ID_SQ') == 1)
+   end
+end