aq1018-sqlserver-2000-2008-adpater 0.0.2

data/test/cases/basics_test_sqlserver.rb

@@ -0,0 +1,21 @@
+require 'cases/sqlserver_helper'
+require 'models/developer'
+
+class BasicsTestSqlserver < ActiveRecord::TestCase
+end
+
+class BasicsTest < ActiveRecord::TestCase
+  
+  COERCED_TESTS = [:test_read_attributes_before_type_cast_on_datetime]
+  
+  include SqlserverCoercedTest
+  
+  fixtures :developers
+  
+  def test_coerced_test_read_attributes_before_type_cast_on_datetime
+    developer = Developer.find(:first)
+    assert_equal developer.created_at.to_s(:db)+'.000' , developer.attributes_before_type_cast["created_at"]
+  end
+  
+  
+end

data/test/cases/calculations_test_sqlserver.rb

@@ -0,0 +1,20 @@
+require 'cases/sqlserver_helper'
+require 'models/company'
+
+class CalculationsTestSqlserver < ActiveRecord::TestCase
+end
+
+class CalculationsTest < ActiveRecord::TestCase
+  
+  COERCED_TESTS = [:test_should_sum_expression]
+  
+  include SqlserverCoercedTest
+  
+  fixtures :accounts
+  
+  def test_coerced_test_should_sum_expression
+    assert_equal 636, Account.sum("2 * credit_limit")
+  end
+  
+  
+end

data/test/cases/column_test_sqlserver.rb

@@ -0,0 +1,246 @@
+require 'cases/sqlserver_helper'
+require 'models/binary'
+
+class ColumnTestSqlserver < ActiveRecord::TestCase
+  
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @column_klass = ActiveRecord::ConnectionAdapters::SQLServerColumn
+  end
+  
+  should 'return real_number as float' do
+    assert_equal :float, TableWithRealColumn.columns_hash["real_number"].type
+  end
+  
+  should 'know its #table_name and #table_klass' do
+    Topic.columns.each do |column|
+      assert_equal 'topics', column.table_name, "This column #{column.inspect} did not know it's #table_name"
+      assert_equal Topic, column.table_klass, "This column #{column.inspect} did not know it's #table_klass"
+    end
+  end
+  
+  should 'return correct null, limit, and default for Topic' do
+    tch = Topic.columns_hash
+    assert_equal false, tch['id'].null
+    assert_equal true,  tch['title'].null
+    assert_equal 255,   tch['author_name'].limit
+    assert_equal true,  tch['approved'].default
+    assert_equal 0,     tch['replies_count'].default
+  end
+  
+  context 'For binary columns' do
+
+    setup do
+      @binary_string = "GIF89a\001\000\001\000\200\000\000\377\377\377\000\000\000!\371\004\000\000\000\000\000,\000\000\000\000\001\000\001\000\000\002\002D\001\000;"
+      @saved_bdata = Binary.create!(:data => @binary_string)
+    end
+    
+    should 'read and write binary data equally' do
+      assert_equal @binary_string, Binary.find(@saved_bdata).data
+    end
+    
+    should 'have correct attributes' do
+      column = Binary.columns_hash['data']
+      assert_equal :binary, column.type
+      assert_equal @connection.native_binary_database_type, column.sql_type
+      assert_equal nil, column.limit
+    end
+    
+    should 'quote data for sqlserver with literal 0x prefix' do
+      # See the output of the stored procedure: 'exec sp_datatype_info'
+      sqlserver_encoded_bdata = "0x47494638396101000100800000ffffff00000021f90400000000002c00000000010001000002024401003b"
+      assert_equal sqlserver_encoded_bdata, @column_klass.string_to_binary(@binary_string) 
+    end
+
+  end
+  
+  context 'For string columns' do
+
+    setup do
+      @char         = SqlServerString.columns_hash['char']
+      @char10       = SqlServerString.columns_hash['char_10']
+      @varcharmax   = SqlServerString.columns_hash['varchar_max']
+      @varcharmax10 = SqlServerString.columns_hash['varchar_max_10']
+    end
+
+    should 'have correct simplified types' do
+      assert_equal :string, @char.type
+      assert_equal :string, @char10.type
+      if sqlserver_2005?
+        assert_equal :string, @varcharmax.type
+        assert_equal :string, @varcharmax10.type
+      end
+    end
+    
+    should 'have correct #sql_type per schema definition' do
+      assert_equal 'char(1)',     @char.sql_type,       'Specifing a char type with no limit is 1 by SQL Server standards.'
+      assert_equal 'char(10)',    @char10.sql_type,      @char10.inspect
+      if sqlserver_2005?
+        assert_equal 'varchar(max)', @varcharmax.sql_type,   'A -1 limit should be converted to max (max) type.'
+        assert_equal 'varchar(max)', @varcharmax10.sql_type, 'A -1 limit should be converted to max (max) type.'
+      end
+    end
+    
+    should 'have correct #limit per schema definition' do
+      assert_equal 1,   @char.limit
+      assert_equal 10,  @char10.limit
+      if sqlserver_2005?
+        assert_equal nil, @varcharmax.limit,   'Limits on max types are moot and we should let rails know that.'
+        assert_equal nil, @varcharmax10.limit, 'Limits on max types are moot and we should let rails know that.'
+      end
+    end
+
+  end
+  
+  
+  context 'For all national/unicode columns' do
+    
+    setup do
+      @nchar         = SqlServerUnicode.columns_hash['nchar']
+      @nvarchar      = SqlServerUnicode.columns_hash['nvarchar']
+      @ntext         = SqlServerUnicode.columns_hash['ntext']
+      @ntext10       = SqlServerUnicode.columns_hash['ntext_10']
+      @nchar10       = SqlServerUnicode.columns_hash['nchar_10']
+      @nvarchar100   = SqlServerUnicode.columns_hash['nvarchar_100']
+      @nvarcharmax   = SqlServerUnicode.columns_hash['nvarchar_max']
+      @nvarcharmax10 = SqlServerUnicode.columns_hash['nvarchar_max_10']
+    end
+    
+    should 'all respond true to #is_utf8?' do
+      SqlServerUnicode.columns_hash.except('id').values.each do |column|
+        assert column.is_utf8?, "This column #{column.inspect} should have been a unicode column."
+      end
+    end
+    
+    should 'have correct simplified types' do
+      assert_equal :string, @nchar.type
+      assert_equal :string, @nvarchar.type
+      assert_equal :text,   @ntext.type
+      assert_equal :text,   @ntext10.type
+      assert_equal :string, @nchar10.type
+      assert_equal :string, @nvarchar100.type
+      if sqlserver_2005?
+        assert_equal :string, @nvarcharmax.type
+        assert_equal :string, @nvarcharmax10.type
+      end
+    end
+    
+    should 'have correct #sql_type per schema definition' do
+      assert_equal 'nchar(1)',      @nchar.sql_type,       'Specifing a nchar type with no limit is 1 by SQL Server standards.'
+      assert_equal 'nvarchar(255)', @nvarchar.sql_type,    'Default nvarchar limit is 255.'
+      assert_equal 'ntext',         @ntext.sql_type,       'Nice and clean ntext, limit means nothing here.'
+      assert_equal 'ntext',         @ntext10.sql_type,     'Even a next with a limit of 10 specified will mean nothing.'
+      assert_equal 'nchar(10)',     @nchar10.sql_type,     'An nchar with a limit of 10 needs to have it show up here.'
+      assert_equal 'nvarchar(100)', @nvarchar100.sql_type, 'An nvarchar with a specified limit of 100 needs to show it.'
+      if sqlserver_2005?
+        assert_equal 'nvarchar(max)', @nvarcharmax.sql_type,   'A -1 limit should be converted to max (max) type.'
+        assert_equal 'nvarchar(max)', @nvarcharmax10.sql_type, 'A -1 limit should be converted to max (max) type.'
+      end
+    end
+    
+    should 'have correct #limit per schema definition' do
+      assert_equal 1,   @nchar.limit
+      assert_equal 255, @nvarchar.limit
+      assert_equal nil, @ntext.limit,       'An ntext column limit is moot, it is a fixed variable length'
+      assert_equal 10,  @nchar10.limit
+      assert_equal 100, @nvarchar100.limit
+      if sqlserver_2005?
+        assert_equal nil, @nvarcharmax.limit,   'Limits on max types are moot and we should let rails know that.'
+        assert_equal nil, @nvarcharmax10.limit, 'Limits on max types are moot and we should let rails know that.'
+      end
+    end
+    
+  end
+  
+  context 'For datetime columns' do
+
+    setup do
+      @date = SqlServerChronic.columns_hash['date']
+      @time = SqlServerChronic.columns_hash['time']
+      @datetime = SqlServerChronic.columns_hash['datetime']
+    end
+
+    should 'have correct simplified type for uncast datetime' do
+      assert_equal :datetime, @datetime.type
+    end
+    
+    should 'all be a datetime #sql_type' do
+      assert_equal 'datetime', @date.sql_type
+      assert_equal 'datetime', @time.sql_type
+      assert_equal 'datetime', @datetime.sql_type
+    end
+    
+    should 'all be have nil #limit' do
+      assert_equal nil, @date.limit
+      assert_equal nil, @time.limit
+      assert_equal nil, @datetime.limit
+    end
+    
+    context 'which have coerced types' do
+      
+      setup do
+        christmas_08 = "2008-12-25".to_time
+        christmas_08_afternoon = "2008-12-25 12:00".to_time
+        @chronic_date = SqlServerChronic.create!(:date => christmas_08).reload
+        @chronic_time = SqlServerChronic.create!(:time => christmas_08_afternoon).reload
+      end
+      
+      should 'have an inheritable attribute ' do
+        assert SqlServerChronic.coerced_sqlserver_date_columns.include?('date')
+      end
+      
+      should 'have column and objects cast to date' do
+        assert_equal :date, @date.type, "This column: \n#{@date.inspect}"
+        assert_instance_of Date, @chronic_date.date
+      end
+      
+      should 'have column objects cast to time' do
+        assert_equal :time, @time.type, "This column: \n#{@time.inspect}"
+        assert_instance_of Time, @chronic_time.time
+      end
+      
+    end
+
+  end
+  
+  context 'For decimal and numeric columns' do
+    
+    setup do
+      @bank_balance = NumericData.columns_hash['bank_balance']
+      @big_bank_balance = NumericData.columns_hash['big_bank_balance']
+      @world_population = NumericData.columns_hash['world_population']
+      @my_house_population = NumericData.columns_hash['my_house_population']
+    end
+    
+    should 'have correct simplified types' do
+      assert_equal :decimal, @bank_balance.type
+      assert_equal :decimal, @big_bank_balance.type
+      assert_equal :integer, @world_population.type, 'Since #extract_scale == 0'
+      assert_equal :integer, @my_house_population.type, 'Since #extract_scale == 0'
+    end
+    
+    should 'have correct #sql_type' do
+      assert_equal 'decimal(10,2)', @bank_balance.sql_type
+      assert_equal 'decimal(15,2)', @big_bank_balance.sql_type
+      assert_equal 'decimal(10,0)', @world_population.sql_type
+      assert_equal 'decimal(2,0)',  @my_house_population.sql_type
+    end
+    
+    should 'have correct #limit' do
+      assert_equal nil, @bank_balance.limit
+      assert_equal nil, @big_bank_balance.limit
+      assert_equal nil, @world_population.limit
+      assert_equal nil, @my_house_population.limit
+    end
+    
+    should 'return correct precisions and scales' do
+      assert_equal [10,2], [@bank_balance.precision, @bank_balance.scale]
+      assert_equal [15,2], [@big_bank_balance.precision, @big_bank_balance.scale]
+      assert_equal [10,0], [@world_population.precision, @world_population.scale]
+      assert_equal [2,0],  [@my_house_population.precision, @my_house_population.scale]
+    end
+    
+  end
+  
+  
+end

data/test/cases/connection_test_sqlserver.rb

@@ -0,0 +1,103 @@
+require 'cases/sqlserver_helper'
+require 'models/reply' 
+
+class ConnectionTestSqlserver < ActiveRecord::TestCase
+  
+  self.use_transactional_fixtures = false
+  
+  fixtures :topics, :accounts
+  
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+  
+  
+  should 'return finished DBI statment handle from #execute without block' do
+    handle = @connection.execute('SELECT * FROM [topics]')
+    assert_instance_of DBI::StatementHandle, handle
+    assert handle.finished?
+  end
+  
+  should 'finish DBI statment handle from #execute with block' do
+    assert_all_statements_used_are_closed do
+      @connection.execute('SELECT * FROM [topics]') { }
+    end
+  end
+  
+  should 'return an unfinished DBI statement handler from #raw_execute' do
+    handle = @connection.send(:raw_execute,'SELECT * FROM [topics]')
+    assert_instance_of DBI::StatementHandle, handle
+    assert !handle.finished?
+  end
+  
+  should 'finish connection from #raw_select' do
+    assert_all_statements_used_are_closed do
+      @connection.send(:raw_select,'SELECT * FROM [topics]')
+    end
+  end
+  
+  should 'affect rows' do
+    assert Topic.connection.instance_variable_get("@connection")["AutoCommit"]
+    topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
+    updated = Topic.update(topic_data.keys, topic_data.values)
+    assert_equal 2, updated.size
+    assert_equal "1 updated", Topic.find(1).content
+    assert_equal "2 updated", Topic.find(2).content
+    assert_equal 2, Topic.delete([1, 2])        
+  end
+  
+  should 'execute without block closes statement' do
+    assert_all_statements_used_are_closed do
+      @connection.execute("SELECT 1")
+    end
+  end
+  
+  should 'execute with block closes statement' do
+    assert_all_statements_used_are_closed do
+      @connection.execute("SELECT 1") do |sth|
+        assert !sth.finished?, "Statement should still be alive within block"
+      end
+    end
+  end
+  
+  should 'insert with identity closes statement' do
+    assert_all_statements_used_are_closed do
+      @connection.insert("INSERT INTO accounts ([id], [firm_id],[credit_limit]) values (999, 1, 50)")
+    end
+  end
+  
+  should 'insert without identity closes statement' do
+    assert_all_statements_used_are_closed do
+      @connection.insert("INSERT INTO accounts ([firm_id],[credit_limit]) values (1, 50)")
+    end
+  end
+
+  should 'active closes statement' do
+    assert_all_statements_used_are_closed do
+      @connection.active?
+    end
+  end
+  
+  
+  private
+  
+  def assert_all_statements_used_are_closed(&block)
+    existing_handles = []
+    ObjectSpace.each_object(DBI::StatementHandle) {|handle| existing_handles << handle}
+    GC.disable
+    yield
+    used_handles = []
+    ObjectSpace.each_object(DBI::StatementHandle) {|handle| used_handles << handle unless existing_handles.include? handle}
+    assert_block "No statements were used within given block" do
+      used_handles.size > 0
+    end
+    ObjectSpace.each_object(DBI::StatementHandle) do |handle|
+      assert_block "Statement should have been closed within given block" do
+        handle.finished?
+      end
+    end
+  ensure
+    GC.enable
+  end
+
+end

data/test/cases/eager_association_test_sqlserver.rb

@@ -0,0 +1,22 @@
+require 'cases/sqlserver_helper'
+require 'models/author'
+require 'models/post'
+require 'models/comment'
+
+class EagerAssociationTestSqlserver < ActiveRecord::TestCase
+end
+
+class EagerAssociationTest < ActiveRecord::TestCase
+  
+  COERCED_TESTS = [:test_count_with_include]
+  
+  include SqlserverCoercedTest
+  
+  fixtures :authors, :posts, :comments
+  
+  def test_coerced_test_count_with_include
+    assert_equal 3, authors(:david).posts_with_comments.count(:conditions => "len(comments.body) > 15")
+  end
+  
+  
+end

data/test/cases/inheritance_test_sqlserver.rb

@@ -0,0 +1,28 @@
+require 'cases/sqlserver_helper'
+require 'models/company'
+
+class InheritanceTestSqlserver < ActiveRecord::TestCase
+end
+
+class InheritanceTest < ActiveRecord::TestCase
+  
+  COERCED_TESTS = [
+    :test_eager_load_belongs_to_primary_key_quoting,
+    :test_a_bad_type_column
+  ]
+  
+  include SqlserverCoercedTest
+  
+  def test_coerced_test_eager_load_belongs_to_primary_key_quoting
+    assert_sql(/\(\[companies\].\[id\] = 1\)/) do
+      Account.find(1, :include => :firm)
+    end
+  end
+  
+  def test_coerced_test_a_bad_type_column
+    Company.connection.insert "INSERT INTO [companies] ([id], #{QUOTED_TYPE}, [name]) VALUES(100, 'bad_class!', 'Not happening')"
+    assert_raises(ActiveRecord::SubclassNotFound) { Company.find(100) }
+  end
+  
+  
+end