ramen 0.4.0

data/test/test_ramen.rb

@@ -0,0 +1,274 @@
+#--
+# Copyright (c) 2007 Gregory N. Houston
+# See ramen.rb for license information.
+#++
+require 'test/unit'
+require 'lib/ramen'
+require 'ruby-prof'
+require 'singleton'
+require 'dbi'
+require 'yaml'
+require 'test/helper.rb'
+require 'test/test_bugs'
+
+# not a very good test suite, but even so it has proved invaluable when
+# making changes to ensure everything is still working.
+#
+# dependencies:
+#   * on the AdventureWorks database which is installed by SQL Server as a demo database.
+#   * depends on a predefined ODBC conncetion named 'ramen_test' which connects
+#     to AdventureWorks
+#
+module Ramen
+  PROFILE = false
+
+class TestDatabases
+  include Singleton
+  
+  attr_reader :dbs, :connections
+  def const_get( const_name )
+  const_name.to_s.split('::').inject( Kernel ) { |mod,  name|  mod.const_get( name )  }
+  end
+
+  def initialize
+    config = Helper.load_config
+
+    @connections = Hash.new
+    @dbs = Hash.new
+    
+    config.each do |name, settings|
+      @connections[name] = DBI.connect(settings['connection'])
+      @dbs[name] = Ramen.create( :connection => @connections[name], :sql => const_get(settings["engine"]))
+    end
+  end
+  
+  def test
+    @dbs.keys.each do |key|
+      yield key, @dbs[key]
+    end
+  end
+  
+  def test_with_conn
+    @dbs.keys.each do |key|
+      yield key, @dbs[key], @connections[key]
+    end
+  end
+end
+
+class Test_Ramen < Test::Unit::TestCase
+  include TestBugs
+
+  def setup
+    if PROFILE
+      RubyProf.start
+    end
+  end
+  
+  def teardown
+    if PROFILE
+      result = RubyProf.stop
+      printer = RubyProf::GraphHtmlPrinter.new(result)
+      printer.print(open("doc/profile_#{@name}.html",'w'), 0)
+    end
+  end
+  
+  def t2_list_tables( key, db, conn )
+    @name = "test_list_tables_#{key}"
+    tables = db.list_tables(conn)
+    result = tables.select { |e| e[1].downcase == 'employee'}
+    assert_equal( 1, result.length )
+  end
+  
+  def t_table_access( key, db )
+    @name = "test_table_access_#{key}"
+    
+    employee = db.schema['RamenTestSchema'].table['Employee']
+    assert_equal( 0, employee.is_published ) if employee.respond_to? :is_published #sql2005
+    assert_equal( 1, employee.auto_increment ) if employee.respond_to? :auto_increment # mysql
+    
+    if employee.respond_to? :table_id then
+      employee = db.schema['RamenTestSchema'].table[employee.table_id]
+      assert_equal( 'Employee', employee.table_name )
+    end
+  end
+  
+  def t_column_access( key, db )
+    @name = "test_table_column_access_#{key}"
+    table = db.schema['RamenTestSchema'].table['Employee']
+    column = table.column['LoginID']
+    if column.respond_to? :max_length # sql2005
+      assert_equal( 512, column.max_length ) 
+    elsif column.respond_to? :character_maximum_length # mysql
+      assert_equal( 256, column.character_maximum_length )
+    else
+      fail("dont know how to test column length, please update the test code.")
+    end
+  end
+  
+  def t_foreign_key_access( key, db )
+    @name = "test_foreign_key_access_#{key}"
+    table = db.schema['RamenTestSchema'].table['Employee']
+    assert_equal( 'ManagerID', table.fk['FK_Employee_Employee_ManagerID'].column['ManagerID'].column_name )
+  end
+  
+  def t_index_access( key, db )
+    @name = "test_index_access_#{key}"
+    table = db.schema['RamenTestSchema'].table['Employee']
+    assert_equal( 'employee', table.index['IX_Employee_LoginID'].table_name.downcase )
+    assert_equal( 'loginid', table.index['IX_Employee_LoginID'].column['LoginID'].column_name.downcase )
+  end
+  
+  def t_index_nonunique_access( key, db )
+    @name = "test_index_nonunique_access_#{key}"
+    index = db.schema['RamenTestSchema'].table['Employee'].index['IX_Employee_ManagerID']
+    assert_equal( 'ManagerID', index.column['ManagerID'].column_name )    
+    assert_equal( 0, index.is_unique ) if index.respond_to? :is_unique # sql 2005
+    assert_equal( 1, index.non_unique ) if index.respond_to? :non_unique # mysql
+  end
+  
+  def t_primary_key_access( key, db )
+    @name = "test_primary_key_access_#{key}"
+    table = db.schema['RamenTestSchema'].table['Employee']
+    assert_equal( 1, table.pk.is_primary_key ) if table.pk.respond_to? :is_primary_key
+    assert_equal( 'employeeid', table.pk.column['EmployeeID'].column_name.downcase )
+  end
+  
+  def t2_all( key, db, conn )
+    @name = "test_all_#{key}"
+    db.list_tables(conn).each do |record|
+      schema = db.schema[ record[0] ]
+      assert_not_nil( schema )
+      table  = db.schema[ record[0] ].table[ record[1] ]
+      assert_not_nil( table )
+    end
+  end
+  
+  def t_schema_by_name( key, db )
+    @name = "test_schema_by_name_#{key}"
+    assert_equal( 'ramentestschema', db.schema['RamenTestSchema'].schema_name.downcase )
+  end
+
+# TODO -- support key constraints
+# 
+#  def t_key( key, db )
+#    @name = "test_key_#{key}"
+#    key = db.schema['RamenTestSchema'].table['Employee'].key['PK_Employee_EmployeeID']
+#    assert_not_nil( key )
+#  end
+  
+  def t_inspect( key, db )
+    @name = "test_inspect_#{key}"
+    db_text = db.inspect
+    assert_match(/Database/, db_text)
+    
+    schema = db.schema['RamenTestSchema'].inspect
+    assert_match(/Schema/, schema)
+    assert_match(/RamenTestSchema/i, schema)
+    
+    table = db.schema['RamenTestSchema'].table['Employee'].inspect
+    assert_match(/Table/, table)
+    assert_match(/Employee /i, table)
+  end
+  
+  def t_compare_same_type( key, db )    
+    @name = "test_compare_#{key}"
+    a = db.schema['RamenTestSchema']
+    b = db.schema['RamenTestSchema2']
+    assert_equal( -1, a <=> b)
+    assert_equal( 1, b <=> a)
+    assert_equal( 0, a <=> a)
+  end
+  
+  def t_compare_diff_type( key, db )
+    @name = "test_compare_diff_type_#{key}"
+    a = db.schema['RamenTestSchema']
+    b = 42
+    assert_equal( nil, a <=> b)
+    assert_equal( nil, b <=> a)
+  end
+  
+  def t_compare_nil( key, db )
+    @name = "test_compare_nil_#{key}"
+    a = db.schema['RamenTestSchema']
+    b = nil
+    assert_equal( nil, a <=> b)
+    assert_equal( -1, b <=> a )
+    #assert_raise( NoMethodError ) { b <=> a }
+  end
+  
+  def t_compare_row_data_gateway( key, db )
+    @name = "test_compare_row_data_gateway_#{key}"
+    a = db.schema['RamenTestSchema']
+    b = db.schema['RamenTestSchema'].table['Employee']
+    assert_equal( 1, a <=> b)
+    assert_equal( -1, b <=> a)
+  end
+
+  def t_compare_all( key, db )
+    @name = "test_compare_all_#{key}"
+    compare_helper db.schema['RamenTestSchema'], db.schema['RamenTestSchema2']
+    employee = db.schema['RamenTestSchema'].table['Employee']
+    address = db.schema['RamenTestSchema'].table['EmployeeAddress']
+    compare_helper employee, address
+    compare_helper employee.column['LoginID'], employee.column['ManagerID']
+    compare_helper address.fk['FK_EmployeeAddress_Employee'], employee.fk['FK_Employee_Employee_ManagerID']
+    compare_helper address.fk['FK_EmployeeAddress_Employee'].column['EmployeeID'], employee.fk['FK_Employee_Employee_ManagerID'].column['ManagerID']
+    compare_helper employee.index['IX_Employee_LoginID'], employee.index['IX_Employee_ManagerID']
+    compare_helper employee.index['IX_Employee_LoginID'].column['LoginID'], employee.index['IX_Employee_ManagerID'].column['ManagerID']
+    unless address.pk.primary_key_name == 'PRIMARY' and employee.pk.primary_key_name == 'PRIMARY' then # mysql
+      compare_helper address.pk, employee.pk
+    end
+    compare_helper address.pk.column['AddressID'], employee.pk.column['EmployeeID'] 
+#    compare_helper address.key['PK_EmployeeAddress_EmployeeID_AddressID'], employee.key['PK_Employee_EmployeeID']
+  end
+  
+  def compare_helper( a, b )
+    msg = "#{a.inspect} #{b.inspect}"
+    assert_equal( -1, a <=> b, "a <=> b; #{msg}")
+    assert_equal(  1, b <=> a, "b <=> a; #{msg}")
+    assert_equal(  0, a <=> a, "a <=> a; #{msg}")
+  end
+  
+  self.instance_methods.each do |method_name|
+    if method_name =~ /^t_/ then
+      define_method(method_name.sub(/^t_/, 'test_').to_sym) do
+        TestDatabases.instance.test do | key, db |
+          begin
+            self.send(method_name.to_sym, key, db)
+          rescue Exception => e
+            unless e.respond_to? :old_message
+              e.singleton_class.module_eval do
+                alias :old_message :message
+                define_method :message do
+                  "#{old_message}; engine=#{key}"       
+                end
+              end
+            end
+            raise
+          end
+        end
+      end
+    end
+    
+    if method_name =~ /^t2_/ then
+      define_method(method_name.sub(/^t2_/, 'test_').to_sym) do
+        TestDatabases.instance.test_with_conn do | key, db, conn |
+          begin
+            self.send(method_name.to_sym, key, db, conn)
+          rescue Exception => e
+            unless e.respond_to? :old_message
+              e.singleton_class.module_eval do
+                alias :old_message :message
+                define_method :message do
+                  "#{key}: #{old_message}"
+                end
+              end
+            end
+            raise
+          end
+        end
+      end
+    end
+  end
+end
+end

data/test/test_ramen_hash.rb

@@ -0,0 +1,78 @@
+#--
+# Copyright (c) 2007 Gregory N. Houston
+# See ramen.rb for license information.
+#++
+
+require 'test/unit'
+require 'lib/ramen'
+
+module Ramen
+  class ObjToStoreInHash
+    attr_reader :obj_id, :obj_name
+    def initialize( id, name )
+      @obj_id = id
+      @obj_name = name
+    end
+  end
+
+  class TestRamenHash < Test::Unit::TestCase
+    def setup
+      @obj1 = ObjToStoreInHash.new( 1, 'One' )
+      @obj2 = ObjToStoreInHash.new( 2, 'Two' )
+      @collection = RamenHash.new( ObjToStoreInHash, 'obj' )
+      @collection.add( @obj1 )
+      @collection.add( @obj2 )
+    end
+    
+    def test_hash
+      assert_equal(@obj1, @collection[1])
+      assert_equal(@obj1, @collection['One'])
+
+      assert_equal(@obj2, @collection[2])
+      assert_equal(@obj2, @collection['Two'])
+    end
+    
+    def test_no_assignment
+      assert_raise NoMethodError do
+        @collection[5] = 5
+      end
+    end
+    
+    def test_wrong_class
+      assert_raise RamenError do
+        @collection.add( Object.new )
+      end
+    end
+    
+    def test_each_by_name
+      @collection.each_by_name do |name,value|
+        assert( (['one','two'].include? name), "name must be either one or two, name=#{name}")
+        assert_same( @collection[name], value )
+      end
+    end
+    
+    def test_each_by_id
+      @collection.each_by_id do |id,value|
+        assert( ([1,2].include? id), "id must be either 1 or 2, id=#{id}")
+        assert_same( @collection[id], value )
+      end
+    end
+    
+    def test_each
+      @collection.each do |obj|
+        assert( ([1,2].include? obj.obj_id), "id must be either 1 or 2, id=#{obj.obj_id}")
+      end
+    end
+    
+    def test_to_s
+      # simply exercise to_s to ensure it doesn't throw exception
+      @collection.to_s
+    end
+    
+    def test_default
+      assert_raise RamenError do
+        @collection['I-am-not-in-the-collection']
+      end
+    end
+  end
+end

data/test/test_ramen_module.rb

@@ -0,0 +1,21 @@
+#--
+# Copyright (c) 2007 Gregory N. Houston
+# See ramen.rb for license information.
+#++
+require 'test/unit'
+require 'lib/ramen'
+require 'dbi'
+
+module Ramen
+class TestRamenModule < Test::Unit::TestCase
+  def test_create_error
+    assert_raise RamenError do
+      Ramen.create( :connection => nil )
+    end
+
+    assert_raise RamenError do
+      Ramen.create()
+    end
+  end
+end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: ramen
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+date: 2008-03-14 00:00:00 -05:00
+summary: Ramen, database reflection library.  Easy access to the definition of schemas, tables, columns, indexes, and foreign keys.
+require_paths: 
+- lib
+email: 
+homepage: http://ramen.rubyforge.org/
+rubyforge_project: ramen
+description: This library provides easy access to the meta-data of a relational database.  Ramen exposes Schema, Tables, Columns, Indexes, and Foreign Keys.  Ramen was developed to support Noodle (also on rubyforge).
+autorequire: ramen
+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
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Gregory N. Houston
+files: 
+- lib/ramen/core.rb
+- lib/ramen/default_logger.rb
+- lib/ramen/engine/engine.rb
+- lib/ramen/engine/mysql.rb
+- lib/ramen/engine/sql2005.rb
+- lib/ramen/home.rb
+- lib/ramen/metadata/column.rb
+- lib/ramen/metadata/database.rb
+- lib/ramen/metadata/foreign_key.rb
+- lib/ramen/metadata/foreign_key_column.rb
+- lib/ramen/metadata/index.rb
+- lib/ramen/metadata/index_column.rb
+- lib/ramen/metadata/key_constraint.rb
+- lib/ramen/metadata/metadata.rb
+- lib/ramen/metadata/primary_key.rb
+- lib/ramen/metadata/primary_key_column.rb
+- lib/ramen/metadata/schema.rb
+- lib/ramen/metadata/table.rb
+- lib/ramen/ramen_error.rb
+- lib/ramen/ramen_hash.rb
+- lib/ramen/ramen_module.rb
+- lib/ramen/row_data_gateway.rb
+- lib/ramen/version.rb
+- lib/ramen.rb
+- test/config
+- test/config/config.yml
+- test/helper.rb
+- test/mysql_create_test_db.sql
+- test/sql2005_create_test_db.sql
+- test/test_bugs.rb
+- test/test_core.rb
+- test/test_default_logger.rb
+- test/test_home.rb
+- test/test_ramen.rb
+- test/test_ramen_hash.rb
+- test/test_ramen_module.rb
+- readme.txt
+- doc/doc_resources/MetaData_Class_Diagram.gif
+- doc/doc_resources/MetaData_Class_Diagram.png
+- doc/doc_resources/Thumbs.db
+test_files: 
+- test/config
+- test/config/config.yml
+- test/helper.rb
+- test/mysql_create_test_db.sql
+- test/sql2005_create_test_db.sql
+- test/test_bugs.rb
+- test/test_core.rb
+- test/test_default_logger.rb
+- test/test_home.rb
+- test/test_ramen.rb
+- test/test_ramen_hash.rb
+- test/test_ramen_module.rb
+rdoc_options: 
+- --main
+- readme.txt
+- --title
+- Ramen for Ruby (rdoc)
+extra_rdoc_files: 
+- readme.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+