iotaz 0.1.0

data/test/GeneratedAttributeTest.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class GeneratedAttributeTest < Test::Unit::TestCase
+   def test01
+      a = GeneratedAttribute.new('att01', 'SEQUENCE', 'INSERT', 'ATT_01_SQ')
+
+      assert(a.type == 'SEQUENCE')
+      assert(a.events == 'INSERT')
+      assert(a.source == 'ATT_01_SQ')
+      assert(a.column == 'att01')
+
+      a = GeneratedAttribute.new('att02', 'DATE', 'UPDATE', 'YESTERDAY', 'COL_NAME')
+
+      assert(a.type == 'DATE')
+      assert(a.events == 'UPDATE')
+      assert(a.source == 'YESTERDAY')
+      assert(a.column == 'COL_NAME')
+      
+      a = GeneratedAttribute.new('att03', 'TIME', 'INSERT, UPDATE', 'NOW')
+
+      assert(a.type == 'TIME')
+      assert(a.events == 'INSERT,UPDATE')
+      assert(a.source == 'NOW')
+      assert(a.column == 'att03')
+      
+      a = GeneratedAttribute.new('att04', 'TIMESTAMP', 'UPDATE, INSERT ', 'NOW')
+
+      assert(a.type == 'TIMESTAMP')
+      assert(a.events == 'UPDATE,INSERT')
+      assert(a.source == 'NOW')
+      assert(a.column == 'att04')
+   end
+   
+   def test02
+      a1 = GeneratedAttribute.new('att01', 'SEQUENCE', 'INSERT', 'ATT_01_SQ')
+      a2 = GeneratedAttribute.new('att01', 'SEQUENCE', 'INSERT', 'ATT_01_SQ')
+      a3 = GeneratedAttribute.new('att04', 'TIMESTAMP', 'UPDATE, INSERT ', 'NOW')
+      
+      assert(a1 == a1)
+      assert(a1 == a2)
+      assert(a1 != a3)
+   end
+   
+   
+   def test03
+      a = GeneratedAttribute.new('TestAttribute', 'TIME', 'INSERT', 'NOW')
+      
+      a.events = 'UPDATE'
+      assert(a.events == 'UPDATE')
+      
+      a.events = 'INSERT, UPDATE'
+      assert(a.events == 'INSERT,UPDATE')
+      
+      a.events = 'UPDATE , INSERT'
+      assert(a.events == 'UPDATE,INSERT')
+      
+      a.type = 'SEQUENCE'
+      assert(a.type == 'SEQUENCE')
+      
+      a.source = 'ANYTHING'
+      assert(a.source = 'ANYTHING')
+      
+      a.type = 'DATE'
+      a.source = 'TODAY'
+      assert(a.source == 'TODAY')
+      
+      a.source = 'YESTERDAY'
+      assert(a.source == 'YESTERDAY')
+      
+      a.source = 'TOMORROW'
+      assert(a.source == 'TOMORROW')
+   end
+   
+   def test04
+      begin
+         GeneratedAttribute.new('name', 'DATE', 'INSERT', 'NOW')
+         assert(false, "1. Able to create an illegal generated attribute.")
+      rescue IotazError
+      end
+
+      begin
+         GeneratedAttribute.new('name', 'TIME', 'INSERT', 'TODAY')
+         assert(false, "2. Able to create an illegal generated attribute.")
+      rescue IotazError
+      end
+
+      begin
+         GeneratedAttribute.new('name', 'TIMESTAMP', 'INSERT', 'TODAY')
+         assert(false, "3. Able to create an illegal generated attribute.")
+      rescue IotazError
+      end
+   end
+   
+   def test05
+      a = GeneratedAttribute.new('name', 'SEQUENCE', 'INSERT', 'BLAH')
+      
+      a.type = 'DATE'
+      begin
+         a.source = 'NOW'
+         assert(false, '1. Illegal update of generated attribute succesful.')
+      rescue IotazError
+      end
+      
+      a.type = 'TIME'
+      begin
+         a.source = 'TOMORROW'
+         assert(false, '2. Illegal update of generated attribute succesful.')
+      rescue IotazError
+      end
+      
+      a.type = 'TIMESTAMP'
+      begin
+         a.source = 'LaLaLa'
+         assert(false, '3. Illegal update of generated attribute succesful.')
+      rescue IotazError
+      end
+   end
+end

data/test/IotazErrorTest.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class IotazErrorTest < Test::Unit::TestCase
+   def test01
+      e = IotazError.new("This is an example message.")
+      
+      assert(e.message == "This is an example message.")
+      assert(e.context == [])
+      assert(e.populate("{0} {1} {2}") == "{0} {1} {2}")
+      
+      e = IotazError.new("{0} = 1, {1} = 2", "One", 2)
+      
+      assert(e.message == "One = 1, 2 = 2")
+      assert(e.context == ["One", 2])
+      assert(e.populate("{0} {1} {2}") == "One 2 {2}")
+   end
+end

data/test/IotazMetaDataTest.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class MetaDataTestClass
+   def initialize
+      @id = @one = @two = @three = @created = @updated = nil
+   end
+   
+   attr_accessor :one, :two, :three, :id, :created, :updated
+end
+
+class IotazMetaDataTest < Test::Unit::TestCase
+   def setup
+      @attributes = []
+      
+      @attributes.push(Attribute.new('attribute01'))
+      @attributes.push(Attribute.new('attribute02'))
+      @attributes.push(Attribute.new('attribute03'))
+      @attributes.push(Attribute.new('attribute04'))
+      @attributes.push(Attribute.new('attribute05'))
+   end
+   
+   def test01
+      t = 0
+      m = IotazMetaData.new(MetaDataTestClass)
+
+      assert(m.name == 'MetaDataTestClass')
+      assert(m.table == 'MetaDataTestClass')
+      m.each {|entry| t = t + 1}
+      assert(t == 0)
+      assert(m.keys == [])
+
+      t = 0
+      m = IotazMetaData.new(MetaDataTestClass, 'TABLE_NAME')
+
+      assert(m.name == 'MetaDataTestClass')
+      assert(m.table == 'TABLE_NAME')
+      m.each {|entry| t = t + 1}
+      assert(t == 0)
+      assert(m.keys == [])
+   end
+   
+   def test02
+      m = IotazMetaData.new(MetaDataTestClass)
+      
+      m.add_attribute(@attributes[0])
+      assert(m.attribute_exists?(@attributes[0].name))
+      assert(m.get_attribute(@attributes[0].name) != nil)
+      assert(m.get_attribute(@attributes[0].name) == @attributes[0])
+      assert(m.keys == [])
+      
+      t = 0
+      m.each {|a| t = t + 1}
+      assert(t == 1)
+      
+      m.delete_attribute(@attributes[0].name)
+      assert(m.attribute_exists?(@attributes[0].name) == false)
+   end
+   
+   def test03
+      m = IotazMetaData.scan(MetaDataTestClass)
+      
+      assert(m.name == 'MetaDataTestClass')
+      assert(m.table == 'MetaDataTestClass')
+      
+      t = 0
+      m.each {|a| t = t + 1}
+      assert(t == 6)
+      
+      assert(m.attribute_exists?('two'))
+      assert(m.attribute_exists?('id'))
+      assert(m.attribute_exists?('created'))
+      assert(m.keys == ["id"])
+      
+      assert(m.get_attribute('one').instance_of?(Attribute))
+      assert(m.get_attribute('created').instance_of?(GeneratedAttribute))
+      
+      m.delete_attribute('id')
+      assert(m.attribute_exists?('id') == false)
+      assert(m.keys == [])
+   end
+end

data/test/ObjectPoolTest.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class ObjectFactory
+   def initialize
+      @current = 0
+   end
+   
+   def create
+      @current += 1
+   end
+   
+   def destroy(object)
+   end
+end
+
+class ObjectPoolTest < Test::Unit::TestCase
+   def setup
+      @factory = ObjectFactory.new
+   end
+   
+   
+   def test01
+      p = ObjectPool.new(@factory, 10)
+
+      assert(p.factory   == @factory)
+      assert(p.idle      == -1)
+      assert(p.interval  == 600)
+      assert(p.maximum   == 10)
+      assert(p.minimum   == 0)
+      assert(p.size      == 0)
+      assert(p.available == 0)
+
+      p = ObjectPool.new(@factory, 20, 5)
+
+      assert(p.factory   == @factory)
+      assert(p.idle      == -1)
+      assert(p.interval  == 600)
+      assert(p.maximum   == 20)
+      assert(p.minimum   == 5)
+      assert(p.size      == 5)
+      assert(p.available == 5)
+
+      p = ObjectPool.new(@factory, 20, 5, 1800)
+
+      assert(p.factory   == @factory)
+      assert(p.idle      == 1800)
+      assert(p.interval  == 600)
+      assert(p.maximum   == 20)
+      assert(p.minimum   == 5)
+      assert(p.size      == 5)
+      assert(p.available == 5)
+
+      p = ObjectPool.new(@factory, 20, 5, 3600, 300)
+
+      assert(p.factory   == @factory)
+      assert(p.idle      == 3600)
+      assert(p.interval  == 300)
+      assert(p.maximum   == 20)
+      assert(p.minimum   == 5)
+      assert(p.size      == 5)
+      assert(p.available == 5)
+   end
+   
+   
+   def test02
+      p = ObjectPool.new(@factory, 10)
+      a = []
+      
+      a.push(p.acquire)
+      assert(a[0] != nil)
+      assert(p.size == 1)
+      assert(p.available == 0)
+      
+      p.release(a[0])
+      
+      assert(p.size == 1)
+      assert(p.available == 1)
+      
+      a.clear
+      10.times do
+         a.push(p.acquire)
+      end
+      
+      begin
+         p.acquire(false)
+         assert(false, "Acquired resource from max'ed out pool")
+      rescue Exception
+      end
+      
+      assert(p.size == 10)
+      assert(p.available == 0)
+      
+      available = 1
+      a.each do |entry|
+         p.release(entry)
+         assert(p.available == available)
+         available += 1
+      end
+   end
+end

data/test/PersistentTest.rb

@@ -0,0 +1,102 @@
+#!/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 PersistentTestClass
+   include Persistent
+   
+   sequence_attr   :id
+   persistent_attr :number, 'accountno'
+   persistent_attr :customer, 'name', true
+   date_attr       :created
+   time_attr       :now, 'nowtime', true, false, false
+   timestamp_attr  :updated, nil, false, true
+   
+   def initialize(number, customer)
+      @number   = number
+      @customer = customer
+   end
+end
+
+class PersistentTest < Test::Unit::TestCase
+   def test01
+      metadata = PersistentTestClass.iotaz_meta_data
+      account  = PersistentTestClass.new('', '')
+      
+      assert(metadata.attribute_exists?('id'))
+      assert(metadata.attribute_exists?('number'))
+      assert(metadata.attribute_exists?('customer'))
+      assert(metadata.attribute_exists?('created'))
+      assert(metadata.attribute_exists?('now'))
+      assert(metadata.attribute_exists?('updated'))
+      
+      attribute = metadata.get_attribute('id')
+      assert(attribute.name == 'id')
+      assert(attribute.accessor == 'id')
+      assert(attribute.mutator == 'id=')
+      assert(attribute.column == 'id')
+      assert(attribute.type == 'SEQUENCE')
+      assert(attribute.is_generated? == true)
+      assert(attribute.source == 'PERSISTENTTESTCLASS_ID_SQ')
+      assert(attribute.events.include?('INSERT') == true)
+      assert(attribute.events.include?('UPDATE') == false)
+      assert(account.methods.include?('id=') == false)
+      
+      attribute = metadata.get_attribute('number')
+      assert(attribute.name == 'number')
+      assert(attribute.accessor == 'number')
+      assert(attribute.mutator == 'number=')
+      assert(attribute.column == 'accountno')
+      assert(account.methods.include?('number=') == true)
+      
+      attribute = metadata.get_attribute('customer')
+      assert(attribute.name == 'customer')
+      assert(attribute.accessor == 'customer')
+      assert(attribute.mutator == 'customer=')
+      assert(attribute.column == 'name')
+      assert(account.methods.include?('customer=') == false)
+
+      attribute = metadata.get_attribute('created')
+      assert(attribute.name == 'created')
+      assert(attribute.accessor == 'created')
+      assert(attribute.mutator == 'created=')
+      assert(attribute.column == 'created')
+      assert(attribute.type == 'DATE')
+      assert(attribute.is_generated? == true)
+      assert(attribute.source == 'TODAY')
+      assert(attribute.events.include?('INSERT') == true)
+      assert(attribute.events.include?('UPDATE') == false)
+      assert(account.methods.include?('created=') == false)
+
+      attribute = metadata.get_attribute('now')
+      assert(attribute.name == 'now')
+      assert(attribute.accessor == 'now')
+      assert(attribute.mutator == 'now=')
+      assert(attribute.column == 'nowtime')
+      assert(attribute.type == 'TIME')
+      assert(attribute.is_generated? == true)
+      assert(attribute.source == 'NOW')
+      assert(attribute.events.include?('INSERT') == true)
+      assert(attribute.events.include?('UPDATE') == false)
+      assert(account.methods.include?('now=') == true)
+
+      attribute = metadata.get_attribute('updated')
+      assert(attribute.name == 'updated')
+      assert(attribute.accessor == 'updated')
+      assert(attribute.mutator == 'updated=')
+      assert(attribute.column == 'updated')
+      assert(attribute.type == 'TIMESTAMP')
+      assert(attribute.is_generated? == true)
+      assert(attribute.source == 'NOW')
+      assert(attribute.events.include?('INSERT') == false)
+      assert(attribute.events.include?('UPDATE') == true)
+      assert(account.methods.include?('updated=') == false)
+   end
+end

data/test/QueryFieldTest.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class QueryFieldTest < Test::Unit::TestCase
+   def setup
+      @metadata = IotazMetaData.new(QueryFieldTest, 'THE_TABLE')
+      
+      @metadata.add_attribute(GeneratedAttribute.new('id', 'SEQUENCE',
+                                                     'INSERT', 'QUERY_ID_SQ'))
+      @metadata.add_attribute(Attribute.new('value01', 'val01'))
+      @metadata.add_attribute(Attribute.new('value02', 'val02'))
+   end
+   
+   
+   def test1
+      field = QueryField.new('value01', @metadata)
+      
+      assert(field.name == 'value01')
+      assert(field.column == 'val01')
+      assert(field.table == @metadata.table)
+      assert(field.fetched == true)
+      assert(field.comparison == nil)
+      assert(field.value == nil)
+      
+      field = QueryField.new('value02', @metadata, false)
+      
+      assert(field.name == 'value02')
+      assert(field.column == 'val02')
+      assert(field.table == @metadata.table)
+      assert(field.fetched? == false)
+      assert(field.comparison == nil)
+      assert(field.value == nil)
+   end
+   
+   def test2
+      field = QueryField.new('value01', @metadata)
+      
+      field.equal_to(nil)
+      assert(field.comparison == 'is null')
+      assert(field.value == nil)
+      
+      field.equal_to(1234)
+      assert(field.comparison == '= ?')
+      assert(field.value == 1234)
+      
+      field.not_equal_to(nil)
+      assert(field.comparison == 'is not null')
+      assert(field.value == nil)
+      
+      field.not_equal_to('lalala')
+      assert(field.comparison == '!= ?')
+      assert(field.value == 'lalala')
+      
+      field.greater_than(1234)
+      assert(field.comparison == '> ?')
+      assert(field.value == 1234)
+      
+      field.less_than('1234')
+      assert(field.comparison == '< ?')
+      assert(field.value == '1234')
+      
+      field.greater_than_or_equal_to('woowoo')
+      assert(field.comparison == '>= ?')
+      assert(field.value == 'woowoo')
+      
+      field.less_than_or_equal_to(5432)
+      assert(field.comparison == '<= ?')
+      assert(field.value == 5432)
+      
+      field.between(1, 10)
+      assert(field.comparison == 'between ? and ?')
+      assert(field.value == [1, 10])
+      
+      field.not_between(25, 100)
+      assert(field.comparison == 'not between ? and ?')
+      assert(field.value == [25, 100])
+      
+      field.in(1, 3, 5, 7 , 9)
+      assert(field.comparison == 'in (1, 3, 5, 7, 9)')
+      assert(field.value == nil)
+      
+      field.not_in('one', 'two', 'three')
+      assert(field.comparison == "not in ('one', 'two', 'three')")
+      assert(field.value == nil)
+
+      begin
+         field.greater_than(nil)
+         assert(fail, 'Added query field > comparison for nil.')
+      rescue Exception
+      end
+
+      begin
+         field.less_than(nil)
+         assert(fail, 'Added query field < comparison for nil.')
+      rescue Exception
+      end
+
+      begin
+         field.greater_than_or_equal_to(nil)
+         assert(fail, 'Added query field >= comparison for nil.')
+      rescue Exception
+      end
+
+      begin
+         field.less_than_or_equal_to(nil)
+         assert(fail, 'Added query field <= comparison for nil.')
+      rescue Exception
+      end
+
+      begin
+         field.between(100, nil)
+         assert(fail, 'Added query field between comparison for nil.')
+      rescue Exception
+      end
+
+      begin
+         field.not_between(100, nil)
+         assert(fail, 'Added query field not between comparison for nil.')
+      rescue Exception
+      end
+
+      begin
+         field.in([])
+         assert(fail, 'Added query field in comparison for empty array.')
+      rescue Exception
+      end
+
+      begin
+         field.not_in([])
+         assert(fail, 'Added query field not in comparison for empty array.')
+      rescue Exception
+      end
+   end
+   
+   
+   def test03
+      field = QueryField.new('value01', @metadata)
+      
+      assert(field.name_match?('value01'))
+      assert(field.name_match?('QueryFieldTest.value01'))
+      assert(field.name_match?('val01'))
+      assert(field.name_match?('THE_TABLE.val01'))
+      assert(field.name_match?(nil) == false)
+      assert(field.name_match?('') == false)
+      assert(field.name_match?('Lalala') == false)
+   end
+end