activerecord-sqlserver-adapter 2.3.24 → 3.0.0

data/test/cases/connection_test_sqlserver.rb

@@ -1,148 +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 '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 '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 'ODBC connection management' do
-
-    should 'return finished ODBC statement handle from #execute without block' do
-      assert_all_odbc_statements_used_are_closed do
-        @connection.execute('SELECT * FROM [topics]')
-      end
-    end
-
-    should 'finish ODBC statement handle from #execute with block' do
-      assert_all_odbc_statements_used_are_closed do
-        @connection.execute('SELECT * FROM [topics]') { }
-      end
-    end
-
-    should 'finish connection from #raw_select' do
-      assert_all_odbc_statements_used_are_closed do
-        @connection.send(:raw_select,'SELECT * FROM [topics]')
-      end
-    end
-
-    should 'execute without block closes statement' do
-      assert_all_odbc_statements_used_are_closed do
-        @connection.execute("SELECT 1")
-      end
-    end
-
-    should 'execute with block closes statement' do
-      assert_all_odbc_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_odbc_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_odbc_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_odbc_statements_used_are_closed do
-        @connection.active?
-      end
-    end
-
-  end if connection_mode_odbc?
-  
-  
-  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_odbc_statements_used_are_closed(&block)
-    odbc = @connection.raw_connection.class.parent
-    existing_handles = []
-    ObjectSpace.each_object(odbc::Statement) { |h| existing_handles << h }
-    existing_handle_ids = existing_handles.map(&:object_id)
-    assert existing_handles.all?(&:finished?), "Somewhere before the block some statements were not closed"
-    GC.disable    
-    yield
-    used_handles = []
-    ObjectSpace.each_object(odbc::Statement) { |h| used_handles << h unless existing_handle_ids.include?(h.object_id) }
-    assert used_handles.size > 0, "No statements were used within given block"
-    assert used_handles.all?(&:finished?), "Statement should have been closed within given block"
-  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
-  
-  
-end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -1,35 +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 tables.first.respond_to?(:keys)
-  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 'allow multiple result sets to be returned' do
-    results1, results2 = @klass.execute_procedure('sp_helpconstraint','accounts')
-    assert_instance_of Array, results1
-    assert results1.first.respond_to?(:keys)
-    assert results1.first['Object Name']
-    assert_instance_of Array, results2
-    assert results2.first.respond_to?(:keys)
-    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
-
-

data/test/cases/migration_test_sqlserver.rb

@@ -1,108 +0,0 @@
-require 'cases/sqlserver_helper'
-require 'models/person'
-
-class MigrationTestSqlserver < ActiveRecord::TestCase
-  
-  def setup
-    @connection = ActiveRecord::Base.connection
-  end
-  
-  context 'For transactions' do
-    
-    setup do
-      @trans_test_table1 = 'sqlserver_trans_table1'
-      @trans_test_table2 = 'sqlserver_trans_table2'
-      @trans_tables = [@trans_test_table1,@trans_test_table2]
-    end
-    
-    teardown do
-      @trans_tables.each do |table_name|
-        ActiveRecord::Migration.drop_table(table_name) if @connection.tables.include?(table_name)
-      end
-    end
-    
-    should 'not create a tables if error in migrations' do
-      begin
-        ActiveRecord::Migrator.up(SQLSERVER_MIGRATIONS_ROOT+'/transaction_table')
-      rescue Exception => e
-        assert_match %r|this and all later migrations canceled|, e.message
-      end
-      assert_does_not_contain @trans_test_table1, @connection.tables
-      assert_does_not_contain @trans_test_table2, @connection.tables
-    end
-    
-  end
-  
-  context 'For changing column' do
-    
-    should 'not raise exception when column contains default constraint' do
-      lock_version_column = Person.columns_hash['lock_version']
-      assert_equal :integer, lock_version_column.type
-      assert lock_version_column.default.present?
-      assert_nothing_raised { @connection.change_column 'people', 'lock_version', :string }
-      Person.reset_column_information
-      lock_version_column = Person.columns_hash['lock_version']
-      assert_equal :string, lock_version_column.type
-      assert lock_version_column.default.nil?
-    end
-    
-    should 'not drop the default contraint if just renaming' do
-      find_default = lambda do 
-        @connection.select_all("EXEC sp_helpconstraint 'defaults','nomsg'").select do |row|     
-          row['constraint_type'] == "DEFAULT on column decimal_number"
-        end.last
-      end
-      default_before = find_default.call
-      @connection.change_column :defaults, :decimal_number, :decimal, :precision => 4
-      default_after = find_default.call
-      assert default_after
-      assert_equal default_before['constraint_keys'], default_after['constraint_keys']
-    end
-    
-  end
-  
-end
-
-
-class MigrationTest < ActiveRecord::TestCase
-  
-  COERCED_TESTS = [:test_add_column_not_null_without_default]
-  
-  include SqlserverCoercedTest
-  
-  def test_coerced_test_add_column_not_null_without_default
-    Person.connection.create_table :testings do |t| 
-      t.column :foo, :string
-      t.column :bar, :string, :null => false
-    end
-    assert_raises(ActiveRecord::StatementInvalid) do
-      Person.connection.execute "INSERT INTO [testings] ([foo], [bar]) VALUES ('hello', NULL)"
-    end
-  ensure
-    Person.connection.drop_table :testings rescue nil
-  end
-  
-end
-
-
-class ChangeTableMigrationsTest < ActiveRecord::TestCase
-  
-  COERCED_TESTS = [:test_string_creates_string_column]
-  
-  include SqlserverCoercedTest
-  
-  def test_coerced_string_creates_string_column
-    with_change_table do |t|
-      @connection.expects(:add_column).with(:delete_me, :foo, coerced_string_column, {})
-      @connection.expects(:add_column).with(:delete_me, :bar, coerced_string_column, {})
-      t.string :foo, :bar
-    end
-  end
-  
-  def coerced_string_column
-    "#{Person.connection.native_string_database_type}(255)"
-  end
-  
-end
-
-

data/test/cases/named_scope_test_sqlserver.rb

@@ -1,21 +0,0 @@
-require 'cases/sqlserver_helper'
-
-class NamedScopeTestSqlserver < ActiveRecord::TestCase
-end
-
-class NamedScopeTest < ActiveRecord::TestCase
-  
-  COERCED_TESTS = [:test_named_scopes_honor_current_scopes_from_when_defined]
-  
-  include SqlserverCoercedTest
-  
-  # See: http://github.com/rails/rails/commit/0dd2f96f5c90f8abacb0fe0757ef7e5db4a4d501#comment_37025
-  # The orig test is a little brittle and fails on other adapters that do not explicitly fall back to a secondary 
-  # sort of id ASC. Since there are duplicate records with comments_count equal to one another. I have found that 
-  # named_scope :ranked_by_comments, :order => "comments_count DESC, id ASC" fixes the ambiguity.
-  def test_coerced_test_named_scopes_honor_current_scopes_from_when_defined
-    assert true
-  end
-  
-  
-end

data/test/cases/offset_and_limit_test_sqlserver.rb

@@ -1,108 +0,0 @@
-require 'cases/sqlserver_helper'
-require 'models/book'
-
-class OffsetAndLimitTestSqlserver < ActiveRecord::TestCase
-  
-  class Account < ActiveRecord::Base; end
-  
-  def setup
-    @connection = ActiveRecord::Base.connection
-  end
-  
-  context 'When selecting with limit' do
-
-    setup do
-      @select_sql = 'SELECT * FROM schema'
-    end
-
-    should 'alter SQL to limit number of records returned' do
-      options = { :limit => 10 }
-      assert_equal('SELECT TOP 10 * FROM schema', @connection.add_limit_offset!(@select_sql, options))
-    end
-
-    should 'only allow integers for limit' do
-      options = { :limit => 'ten' }
-      assert_raise(ArgumentError) {@connection.add_limit_offset!(@select_sql, options) }
-    end
-
-    should 'convert strings which look like integers to integers' do
-      options = { :limit => '42' }
-      assert_nothing_raised(ArgumentError) {@connection.add_limit_offset!(@select_sql, options)}
-    end
-
-    should 'not allow sql injection via limit' do
-      options = { :limit => '1 * FROM schema; DELETE * FROM table; SELECT TOP 10 *'}
-      assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options) }
-    end
-
-  end
-  
-  context 'When selecting with limit and offset' do
-
-    setup do
-      @select_sql = 'SELECT * FROM books'
-      @subquery_select_sql = 'SELECT *, (SELECT TOP 1 id FROM books) AS book_id FROM books'
-      @books = (1..10).map {|i| Book.create!}
-    end
-    
-    teardown do
-      @books.each {|b| b.destroy}
-    end
-
-    should 'have limit if offset is passed' do
-      options = { :offset => 1 }
-      assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options) }
-    end
-
-    should 'only allow integers for offset' do
-      options = { :limit => 10, :offset => 'five' }
-      assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options)}
-    end
-
-    should 'convert strings which look like integers to integers' do
-      options = { :limit => 10, :offset => '5' }
-      assert_nothing_raised(ArgumentError) {@connection.add_limit_offset!(@select_sql, options)}
-    end
-
-    should 'alter SQL to limit number of records returned offset by specified amount' do
-      options = { :limit => 3, :offset => 5 }
-      expected_sql = "SELECT * FROM (SELECT TOP 3 * FROM (SELECT TOP 8 * FROM books) AS tmp1) AS tmp2"
-      assert_equal(expected_sql, @connection.add_limit_offset!(@select_sql, options))
-    end
-    
-    should 'add locks to deepest sub select in limit offset sql that has a limited tally' do
-      options = { :limit => 3, :offset => 5, :lock => 'WITH (NOLOCK)' }
-      expected_sql = "SELECT * FROM (SELECT TOP 3 * FROM (SELECT TOP 8 * FROM books WITH (NOLOCK)) AS tmp1) AS tmp2"
-      @connection.add_limit_offset! @select_sql, options
-      assert_equal expected_sql, @connection.add_lock!(@select_sql,options)
-    end
-
-    # Not really sure what an offset sql injection might look like
-    should 'not allow sql injection via offset' do
-      options = { :limit => 10, :offset => '1 * FROM schema; DELETE * FROM table; SELECT TOP 10 *'}
-      assert_raise(ArgumentError) { @connection.add_limit_offset!(@select_sql, options) }
-    end
-
-    should 'not create invalid SQL with subquery SELECTs with TOP' do
-      options = { :limit => 5, :offset => 1 }
-      expected_sql = "SELECT * FROM (SELECT TOP 5 * FROM (SELECT TOP 6 *, (SELECT TOP 1 id FROM books) AS book_id FROM books) AS tmp1) AS tmp2"
-      assert_equal expected_sql, @connection.add_limit_offset!(@subquery_select_sql,options)
-    end
-    
-    should 'add lock hints to tally sql if :lock option is present' do
-      assert_sql %r|SELECT TOP 1000000000 \* FROM \[people\] WITH \(NOLOCK\)| do
-        Person.all :limit => 5, :offset => 1, :lock => 'WITH (NOLOCK)'
-      end
-    end
-    
-    should 'not add lock hints to tally sql if there is no :lock option' do
-      assert_sql %r|\(SELECT TOP 1000000000 \* FROM \[people\] \)| do
-        Person.all :limit => 5, :offset => 1
-      end
-    end
-    
-  end
-  
-  
-end
-