iotaz 0.1.0

data/test/QueryRowTest.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class QueryRowTest < Test::Unit::TestCase
+   def test01
+      row = QueryRow.new
+      
+      assert(row.size == 0)
+      assert(row.columns == [])
+      assert(row.values == [])
+      
+      row['one']   = 1
+      row['two']   = 2
+      row['three'] = 3
+      
+      assert(row.size == 3)
+      assert(row.exists?('three'))
+      assert(row.exists?('four') == false)
+      assert(row.columns.size == 3)
+      assert(row.columns.include?('ONE'))
+      assert(row.columns.include?('TWO'))
+      assert(row.columns.include?('THREE'))
+      assert(row.values.size == 3)
+      assert(row.values.include?(1))
+      assert(row.values.include?(2))
+      assert(row.values.include?(3))
+      
+      columns = values = 0
+      row.each do |column, value|
+         columns += 1 if ['ONE', 'TWO', 'THREE'].include?(column)
+         values  +=1 if [1, 2, 3].include?(value)
+      end
+      
+      assert(columns == 3)
+      assert(values == 3)
+   end
+end

data/test/QueryTest.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class TestClass
+   attr_accessor :id, :value01, :value02, :value03
+   
+   def TestClass.iotaz_meta_data
+      IotazMetaData.scan(TestClass)
+   end
+end
+
+class QueryTest < Test::Unit::TestCase
+   def test01
+      query = Query.new(TestClass)
+      
+      assert(query.field('id').fetched?)
+      assert(query.field('value01').fetched?)
+      assert(query.field('value02').fetched?)
+      assert(query.field('value03').fetched?)
+      
+      query = Query.new(TestClass, 'id', 'value01', 'value03')
+      
+      assert(query.field('id').fetched?)
+      assert(query.field('value01').fetched?)
+      assert(query.field('value02').fetched? == false)
+      assert(query.field('value03').fetched?)
+   end
+   
+   def test02
+      query = Query.new(TestClass)
+      
+      sql, values = query.to_sql
+      assert(sql == 'select id, value01, value02, value03 from TestClass')
+      assert(values == [])
+      
+      query.field('id').equal_to(1000)
+      sql, values = query.to_sql
+      assert(sql == 'select id, value01, value02, value03 from TestClass '\
+                    'where id = ?')
+      assert(values == [1000])
+      
+      query.field('value02').in(1, 3, 5, 7, 9)
+      sql, values = query.to_sql
+      assert(sql == 'select id, value01, value02, value03 from TestClass '\
+                    'where id = ? and value02 in (1, 3, 5, 7, 9)')
+      assert(values == [1000])
+      
+      query.field('value02').fetched = false
+      sql, values = query.to_sql
+      assert(sql == 'select id, value01, value03 from TestClass '\
+                    'where id = ? and value02 in (1, 3, 5, 7, 9)')
+      assert(values == [1000])
+   end
+end

data/test/SessionTest.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'dbinfo'
+require 'rubygems'
+require_gem 'iotaz'
+require_gem 'fireruby'
+
+include Iotaz
+
+class SessionTestClass
+   include Persistent
+   
+   sequence_attr   :id, 'id', true, 'SIMPLE_ID_SQ'
+   persistent_attr :text
+   date_attr       :create_date, 'createdate'
+   time_attr       :create_time, 'createtime'
+   self.table_name = 'Simple'
+   
+   def initialize(text)
+      @text = text
+   end
+   
+   def ==(object)
+      same = false
+      if object.instance_of?(SessionTestClass)
+         same = (@id == object.id && @text == object.text)
+      end
+      same
+   end
+end
+
+class SessionTest < Test::Unit::TestCase
+   DB_FILE       = './session_test.fdb'
+   TABLE_SQL     = 'create table Simple(id integer not null primary key, '\
+                   'text varchar(100), createdate date not null, createtime '\
+                   'time not null)'
+   GENERATOR_SQL = 'create generator SIMPLE_ID_SQ'
+   
+   # Set up for testing.
+   def setup
+      # Check if the database file exists.
+      @database = FireRuby::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, 1024, nil)
+      
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate(TABLE_SQL)
+         cxn.execute_immediate(GENERATOR_SQL)
+      end
+      
+      # Create the database interface.
+      configuration = {'iotaz.database'                 => 'firebird',
+                       'iotaz.firebird.user'            => DB_USER_NAME,
+                       'iotaz.firebird.password'        => DB_PASSWORD,
+                       'iotaz.firebird.database'        => DB_FILE,
+                       'iotaz.firebird.connections.min' => 0}
+
+      factory       = DatabaseInterfaceFactory.new(configuration)
+      @interface    = factory.create
+      @terminated   = false
+   end
+   
+   # Clean up after testing.
+   def teardown
+      # Shutdown the interface.
+      @interface.shutdown
+      
+      # Drop the database.
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+   end
+   
+   # Test constructors and call backs.
+   def test01
+      session = Session.new(@interface)
+      session.terminate
+      assert(@terminated == false)
+      
+      session = Session.new(@interface, self)
+      session.terminate
+      assert(@terminated == true)
+   end
+   
+   # Test saving, loading and deleting.
+   def test02
+      session = Session.new(@interface)
+      simple  = SessionTestClass.new('Test Text')
+      
+      session.save(simple)
+      assert(simple.id != nil)
+      assert(simple.create_date != nil)
+      assert(simple.create_time != nil)
+      
+      object = session.load(SessionTestClass, simple.id)
+      assert(simple == object)
+      
+      id = session.id
+      session.delete(simple)
+      begin
+         session.load(SessionTestClass, id)
+         assert(false, 'Loaded a deleted record from the database.')
+      rescue Exception
+      end
+   end
+   
+   # Test the transactional aspect.
+   def test03
+      session = Session.new(@interface)
+      simple  = SessionTestClass.new('Test Text')
+      
+      session.start_transaction
+      begin
+         session.save(simple)
+         assert(simple.id != nil)
+         assert(simple.create_date == nil)
+         assert(simple.create_time == nil)
+         
+         begin
+            object = session.load(SessionTestClass, simple.id)
+            assert(false, 'Fetched unsaved record from the database.')
+         rescue Exception
+         end
+         
+         session.commit
+         assert(simple.id != nil)
+         assert(simple.create_date != nil)
+         assert(simple.create_time != nil)
+      rescue Exception => error
+         session.rollback
+         raise error
+      end
+   end
+   
+   # Test the query execution functionality.
+   def test04
+      session = Session.new(@interface)
+      
+      session.save(SessionTestClass.new('Record One'))
+      session.save(SessionTestClass.new('No. Two'))
+      session.save(SessionTestClass.new('Record Three'))
+      session.save(SessionTestClass.new('No. Four'))
+      
+      query = Query.new(SessionTestClass)
+      query.field('id').between(2, 3)
+      rows = session.execute(query)
+      
+      assert(rows.size == 2)
+      rows.each do |row|
+         assert([2, 3].include?(row['ID']))
+      end
+   end
+   
+   # Required to be a callback.
+   def terminating(session)
+      @terminated = true
+   end
+end
+

data/test/UnitTest.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'ActionTest'
+require 'AtomTest'
+require 'AttributeTest'
+require 'DatabaseInterfaceFactoryTest'
+require 'FirebirdInterfaceTest'
+require 'GeneratedAttributeTest'
+require 'IotazErrorTest'
+require 'IotazMetaDataTest'
+require 'ObjectPoolTest'
+require 'PersistentTest'
+require 'QueryFieldTest'
+require 'QueryRowTest'
+require 'QueryTest'
+require 'SessionTest'
+require 'ValueCallbackTest'

data/test/ValueCallbackTest.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems'
+require_gem 'iotaz'
+
+include Iotaz
+
+class CallbackTestClass
+   def initialize(id, value)
+      @id    = id
+      @value = value
+   end
+   
+   def CallbackTestClass.iotaz_meta_data
+      IotazMetaData::scan(CallbackTestClass)
+   end
+   
+   attr_accessor :id, :value
+end
+
+class ValueCallbackTest < Test::Unit::TestCase
+   def setup
+      @attribute = Attribute.new('value')
+      @objects   = []
+      
+      @objects.push(CallbackTestClass.new(1, 1))
+      @objects.push(CallbackTestClass.new(2, "Two"))
+      @objects.push(CallbackTestClass.new(3, 3.0))
+   end
+   
+   
+   def test01
+      v = ValueCallback.new(@objects[0], @attribute.name, "LA LA LA")
+      
+      assert(v.object == @objects[0])
+      assert(v.attribute == @attribute.name)
+      assert(v.sql == 'LA LA LA')
+      assert(v.parameters == [1])
+      
+      v.assign("Changed")
+      assert(@objects[0].value == "Changed")
+   end
+end

data/test/dbinfo.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# This file contains details to used for connecting to a database for testing
+# purposes. If your database does not use the default user names and password
+# then edit this file and change them for testing.
+
+DB_USER_NAME = 'sysdba'
+DB_PASSWORD  = 'masterkey'

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: iotaz
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2005-04-08
+summary: Object-relational mapping library.
+require_paths: 
+  - lib
+email: paw220470@yahoo.ie
+homepage: http://rubyforge.org/projects/iotaz/
+rubyforge_project: 
+description: "Iotaz is an object relational mapping library. At the moment the library only
+  supports the FireRuby library, providing access to the Firebird open source
+  RDBMS, but this might be extended in future."
+autorequire: iotaz
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Peter Wood
+files: 
+  - lib/iotaz
+  - lib/iotaz.rb
+  - lib/iotaz/DatabaseInterfaceFactory.rb
+  - lib/iotaz/FirebirdInterface.rb
+  - lib/iotaz/IotazError.rb
+  - lib/iotaz/MetaData.rb
+  - lib/iotaz/ObjectPool.rb
+  - lib/iotaz/Persistent.rb
+  - lib/iotaz/Query.rb
+  - lib/iotaz/Session.rb
+  - lib/iotaz/WorkSet.rb
+  - test/ActionTest.rb
+  - test/AtomTest.rb
+  - test/AttributeTest.rb
+  - test/DatabaseInterfaceFactoryTest.rb
+  - test/dbinfo.rb
+  - test/FirebirdInterfaceTest.rb
+  - test/GeneratedAttributeTest.rb
+  - test/IotazErrorTest.rb
+  - test/IotazMetaDataTest.rb
+  - test/ObjectPoolTest.rb
+  - test/PersistentTest.rb
+  - test/QueryFieldTest.rb
+  - test/QueryRowTest.rb
+  - test/QueryTest.rb
+  - test/SessionTest.rb
+  - test/UnitTest.rb
+  - test/ValueCallbackTest.rb
+  - doc/PERSISTENT
+  - doc/README
+  - examples/example01.rb
+  - examples/example02.rb
+test_files: 
+  - test/UnitTest.rb
+rdoc_options: 
+  - "--main"
+  - doc/README
+extra_rdoc_files: 
+  - doc/README
+  - doc/PERSISTENT
+executables: []
+extensions: []
+requirements: []
+dependencies: []