activerecord-sqlserver-adapter 2.3.7 → 3.2.18

data/test/cases/attribute_methods_test_sqlserver.rb

@@ -1,33 +0,0 @@
-require 'cases/sqlserver_helper'
-require 'models/topic'
-
-class AttributeMethodsTestSqlserver < ActiveRecord::TestCase
-end
-
-class AttributeMethodsTest < ActiveRecord::TestCase
-  
-  COERCED_TESTS = [
-    :test_typecast_attribute_from_select_to_false,
-    :test_typecast_attribute_from_select_to_true
-  ]
-  
-  include SqlserverCoercedTest
-  
-  fixtures :topics
-  
-  
-  def test_coerced_typecast_attribute_from_select_to_false
-    topic = Topic.create(:title => 'Budget')
-    topic = Topic.find(:first, :select => "topics.*, CASE WHEN 1=2 THEN 1 ELSE 0 END as is_test")
-    assert !topic.is_test?
-  end
-
-  def test_coerced_typecast_attribute_from_select_to_true
-    topic = Topic.create(:title => 'Budget')
-    topic = Topic.find(:first, :select => "topics.*, CASE WHEN 2=2 THEN 1 ELSE 0 END as is_test")
-    assert topic.is_test?
-  end
-  
-  
-end
-

data/test/cases/basics_test_sqlserver.rb

@@ -1,21 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,285 +0,0 @@
-require 'cases/sqlserver_helper'
-require 'models/binary'
-
-class SqlServerEdgeSchema < ActiveRecord::Base; end;
-
-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? || sqlserver_2008?
-        assert_equal :text, @varcharmax.type, @varcharmax.inspect
-        assert_equal :text, @varcharmax10.type, @varcharmax10.inspect
-      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? || sqlserver_2008?
-        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? || sqlserver_2008?
-        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? || sqlserver_2008?
-        assert_equal :text, @nvarcharmax.type, @nvarcharmax.inspect
-        assert_equal :text, @nvarcharmax10.type, @nvarcharmax10.inspect
-      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? || sqlserver_2008?
-        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? || sqlserver_2008?
-        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']
-      @smalldatetime = SqlServerChronic.columns_hash['smalldatetime']
-    end
-
-    should 'have correct simplified type for uncast datetime' do
-      assert_equal :datetime, @datetime.type
-    end
-    
-    should 'use correct #sql_type for different sql server versions' do
-      assert_equal 'datetime', @datetime.sql_type
-      if sqlserver_2000? || sqlserver_2005?
-        assert_equal 'datetime', @date.sql_type
-        assert_equal 'datetime', @time.sql_type
-      else
-        assert_equal 'date', @date.sql_type
-        assert_equal 'time', @time.sql_type
-      end
-    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 'For smalldatetime types' do
-      
-      should 'have created that type using rails migrations' do
-        assert_equal 'smalldatetime', @smalldatetime.sql_type
-      end
-      
-      should 'be able to insert column without truncation warnings or the like' do
-        SqlServerChronic.create! :smalldatetime => Time.now
-      end
-      
-      should 'be able to update column without truncation warnings or the like' do
-        ssc = SqlServerChronic.create! :smalldatetime => 2.days.ago
-        ssc.update_attributes! :smalldatetime => Time.now
-      end
-
-    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') unless sqlserver_2008?
-      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
-  
-  context 'For tinyint columns' do
-
-    setup do
-      @tinyint = SqlServerEdgeSchema.columns_hash['tinyint']
-    end
-
-    should 'be all it should be' do
-      assert_equal :integer, @tinyint.type
-      assert_nil @tinyint.scale
-      assert_equal 'tinyint(1)', @tinyint.sql_type
-    end
-
-  end
-  
-  
-end

data/test/cases/connection_test_sqlserver.rb

@@ -1,146 +0,0 @@
-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 ODBC statment handle from #execute without block' do
-    assert_all_statements_used_are_closed do
-      @connection.execute('SELECT * FROM [topics]')
-    end
-  end
-  
-  should 'finish ODBC statment handle from #execute with block' do
-    assert_all_statements_used_are_closed do
-      @connection.execute('SELECT * FROM [topics]') { }
-    end
-  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
-    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
-  
-  should 'allow usage of :database connection option to remove setting from dsn' do
-    assert_equal 'activerecord_unittest', @connection.current_database
-    begin
-      @connection.use_database('activerecord_unittest2')
-      assert_equal 'activerecord_unittest2', @connection.current_database
-    ensure
-      @connection.use_database
-      assert_equal 'activerecord_unittest', @connection.current_database, 'Would default back to connection options'
-    end
-  end
-  
-  context 'Connection management' do
-    
-    setup do
-      assert @connection.active?
-    end
-    
-    should 'be able to disconnect and reconnect at will' do
-      @connection.disconnect!
-      assert !@connection.active?
-      @connection.reconnect!
-      assert @connection.active?
-    end
-    
-    should 'auto reconnect when setting is on' do
-      with_auto_connect(true) do
-        @connection.disconnect!
-        assert_nothing_raised() { Topic.count }
-        assert @connection.active?
-      end
-    end
-    
-    should 'not auto reconnect when setting is off' do
-      with_auto_connect(false) do
-        @connection.disconnect!
-        assert_raise(ActiveRecord::StatementInvalid) { Topic.count }
-      end
-    end
-    
-  end
-  
-  
-  
-  private
-  
-  def assert_all_statements_used_are_closed(&block)
-    existing_handles = []
-    ObjectSpace.each_object(ODBC::Statement) {|handle| existing_handles << handle}
-    GC.disable
-    yield
-    used_handles = []
-    ObjectSpace.each_object(ODBC::Statement) {|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(ODBC::Statement) do |handle|
-      assert_block "Statement should have been closed within given block" do
-        handle.finished?
-      end
-    end
-  ensure
-    GC.enable
-  end
-  
-  def with_auto_connect(boolean)
-    existing = ActiveRecord::ConnectionAdapters::SQLServerAdapter.auto_connect
-    ActiveRecord::ConnectionAdapters::SQLServerAdapter.auto_connect = boolean
-    yield
-  ensure
-    ActiveRecord::ConnectionAdapters::SQLServerAdapter.auto_connect = existing
-  end
-
-end

data/test/cases/eager_association_test_sqlserver.rb

@@ -1,42 +0,0 @@
-require 'cases/sqlserver_helper'
-require 'models/post'
-require 'models/author'
-require 'models/comment'
-
-class EagerAssociationTestSqlserver < ActiveRecord::TestCase
-end
-
-class EagerAssociationTest < ActiveRecord::TestCase
-  
-  COERCED_TESTS = [
-    :test_count_with_include,
-    :test_eager_with_has_many_and_limit_and_high_offset_and_multiple_array_conditions,
-    :test_eager_with_has_many_and_limit_and_high_offset_and_multiple_hash_conditions
-  ]
-  
-  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
-  
-  def test_coerced_eager_with_has_many_and_limit_and_high_offset_and_multiple_array_conditions
-    assert_queries(2) do
-      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10,
-        :conditions => [ "authors.name = ? and comments.body = ?", 'David', 'go crazy' ])
-      assert_equal 0, posts.size
-    end
-  end
-
-  def test_coerced_eager_with_has_many_and_limit_and_high_offset_and_multiple_hash_conditions
-    assert_queries(2) do
-      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10,
-        :conditions => { 'authors.name' => 'David', 'comments.body' => 'go crazy' })
-      assert_equal 0, posts.size
-    end
-  end unless active_record_2_point_2?
-  
-  
-end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -1,44 +0,0 @@
-require 'cases/sqlserver_helper'
-
-class ExecuteProcedureTestSqlserver < ActiveRecord::TestCase
-  
-  def setup
-    @klass = ActiveRecord::Base
-  end
-  
-  should 'execute a simple procedure' do
-    tables = @klass.execute_procedure :sp_tables
-    assert_instance_of Array, tables
-    assert_instance_of HashWithIndifferentAccess, tables.first
-  end
-  
-  should 'take parameter arguments' do
-    tables = @klass.execute_procedure :sp_tables, 'sql_server_chronics'
-    table_info = tables.first
-    assert_equal 1, tables.size
-    assert_equal (ENV['ARUNIT_DB_NAME'] || 'activerecord_unittest'), table_info[:TABLE_QUALIFIER], "Table Info: #{table_info.inspect}"
-    assert_equal 'TABLE', table_info[:TABLE_TYPE], "Table Info: #{table_info.inspect}"
-  end
-  
-  should 'quote bind vars correctly' do
-    assert_sql(/EXEC sp_tables '%sql_server%', NULL, NULL, NULL, 1/) do
-      @klass.execute_procedure :sp_tables, '%sql_server%', nil, nil, nil, true
-    end if sqlserver_2005? || sqlserver_2008?
-    assert_sql(/EXEC sp_tables '%sql_server%', NULL, NULL, NULL/) do
-      @klass.execute_procedure :sp_tables, '%sql_server%', nil, nil, nil
-    end if sqlserver_2000?
-  end
-  
-  should 'allow multiple result sets to be returned' do
-    results1, results2 = @klass.execute_procedure('sp_helpconstraint','accounts')
-    assert_instance_of Array, results1
-    assert_instance_of HashWithIndifferentAccess, results1.first
-    assert results1.first['Object Name']
-    assert_instance_of Array, results2
-    assert_instance_of HashWithIndifferentAccess, results2.first
-    assert results2.first['constraint_name']
-    assert results2.first['constraint_type']
-  end
-  
-  
-end

data/test/cases/inheritance_test_sqlserver.rb

@@ -1,28 +0,0 @@
-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

data/test/cases/method_scoping_test_sqlserver.rb

@@ -1,28 +0,0 @@
-require 'cases/sqlserver_helper'
-require 'models/developer'
-
-class MethodScopingTestSqlServer < ActiveRecord::TestCase
-end
-
-class NestedScopingTest < ActiveRecord::TestCase
-  
-  COERCED_TESTS = [:test_merged_scoped_find]
-  
-  include SqlserverCoercedTest
-  
-  fixtures :developers
-
-  def test_coerced_test_merged_scoped_find
-    poor_jamis = developers(:poor_jamis)
-    Developer.with_scope(:find => { :conditions => "salary < 100000" }) do
-      Developer.with_scope(:find => { :offset => 1, :order => 'id asc' }) do
-        assert_sql /ORDER BY id ASC/ do
-          assert_equal(poor_jamis, Developer.find(:first, :order => 'id asc'))
-        end
-      end
-    end
-  end
-  
-end
-
-