activerecord-sqlserver-adapter 2.3.7 → 3.2.18

data/test/cases/migration_test_sqlserver.rb

@@ -1,123 +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 setup
-    @connection = Person.connection
-    @connection.create_table :delete_me, :force => true do |t|
-    end
-  end
-
-  def teardown
-    @connection.drop_table :delete_me rescue nil
-  end
-  
-  def test_coerced_string_creates_string_column
-    with_sqlserver_change_table do |t|
-      @connection.expects(:add_column).with(:delete_me, :foo, sqlserver_string_column, {})
-      @connection.expects(:add_column).with(:delete_me, :bar, sqlserver_string_column, {})
-      t.string :foo, :bar
-    end
-  end
-  
-  protected
-
-  def with_sqlserver_change_table
-    @connection.change_table :delete_me do |t|
-      yield t
-    end
-  end
-  
-  def sqlserver_string_column
-    "#{@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
-

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -1,125 +0,0 @@
-require 'cases/sqlserver_helper'
-require 'models/person'
-require 'models/reader'
-
-class PessimisticLockingTestSqlserver < ActiveRecord::TestCase
-  
-  self.use_transactional_fixtures = false
-  fixtures :people, :readers
-  
-  def setup
-    Person.columns; Reader.columns # Avoid introspection queries during tests.
-  end
-  
-  context 'For simple finds with default lock option' do
-
-    should 'lock with simple find' do
-      assert_nothing_raised do
-        Person.transaction do
-          Person.find 1, :lock => true
-        end
-      end
-    end
-
-    should 'lock with scoped find' do
-      assert_nothing_raised do
-        Person.transaction do
-          Person.with_scope(:find => { :lock => true }) do
-            Person.find 1
-          end
-        end
-      end
-    end
-
-    should 'lock with eager find' do
-      assert_nothing_raised do
-        Person.transaction do
-          Person.find 1, :include => :readers, :lock => true
-        end
-      end
-    end
-
-    should 'reload with lock when #lock! called' do
-      assert_nothing_raised do
-        Person.transaction do
-          person = Person.find 1
-          old, person.first_name = person.first_name, 'fooman'
-          person.lock!
-          assert_equal old, person.first_name
-        end
-      end
-    end
-    
-    should 'simply add lock to find all' do
-      assert_sql %r|SELECT \* FROM \[people\] WITH \(NOLOCK\)| do
-        Person.all(:lock => 'WITH (NOLOCK)')
-      end
-    end
-
-  end
-  
-  context 'For paginated finds' do
-    
-    setup do
-      20.times { |n| Person.create!(:first_name => "Thing_#{n}") }
-    end
-    
-    should 'cope with un-locked paginated results' do
-      tally_not_locked = %r|SELECT count\(\*\) as TotalRows from \(SELECT TOP 1000000000 \* FROM \[people\]\s+WITH \(NOLOCK\) \) tally|
-      inner_tmp_not_locked = %r|SELECT TOP 15 \* FROM \[people\] WITH \(NOLOCK\)|
-      # Currently association limiting is not locked like the parent.
-      association_limiting_not_locked = %r|SELECT \[readers\]\.\* FROM \[readers\] WITH \(NOLOCK\) WHERE \(\[readers\]\.person_id IN \(1,2,3,4,5\)\)|
-      assert_sql(tally_not_locked,inner_tmp_not_locked) do
-        Person.all(:include => :readers, :lock => 'WITH (NOLOCK)', :limit => 5, :offset => 10)
-      end
-    end
-
-  end
-  
-  
-  context 'For dueling concurrent connections' do
-    
-    use_concurrent_connections
-
-    should 'no locks does not wait' do
-      first, second = duel { Person.find 1 }
-      assert first.end > second.end
-    end
-    
-    should 'that second lock waits' do
-      assert [0.2, 1, 5].any? { |zzz|
-        first, second = duel(zzz) { Person.find 1, :lock => true }
-        second.end > first.end
-      }
-    end
-    
-  end
-  
-    
-  protected
-  
-  def duel(zzz = 5)
-    t0, t1, t2, t3 = nil, nil, nil, nil
-    a = Thread.new do
-      t0 = Time.now
-      Person.transaction do
-        yield
-        sleep zzz       # block thread 2 for zzz seconds
-      end
-      t1 = Time.now
-    end
-    b = Thread.new do
-      sleep zzz / 2.0   # ensure thread 1 tx starts first
-      t2 = Time.now
-      Person.transaction { yield }
-      t3 = Time.now
-    end
-    a.join
-    b.join
-    assert t1 > t0 + zzz
-    assert t2 > t0
-    assert t3 > t2
-    [t0.to_f..t1.to_f, t2.to_f..t3.to_f]
-  end
-  
-end

data/test/cases/query_cache_test_sqlserver.rb

@@ -1,24 +0,0 @@
-require 'cases/sqlserver_helper'
-require 'models/task'
-
-class QueryCacheTestSqlserver < ActiveRecord::TestCase
-end
-
-class QueryCacheTest < ActiveRecord::TestCase
-  
-  COERCED_TESTS = [:test_cache_does_not_wrap_string_results_in_arrays]
-  
-  include SqlserverCoercedTest
-  
-  fixtures :tasks
-  
-
-  def test_coerced_test_cache_does_not_wrap_string_results_in_arrays
-    Task.cache do
-      assert_instance_of Fixnum, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-    end
-  end
-  
-end
-
-

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -1,72 +0,0 @@
-require 'cases/sqlserver_helper'
-
-class SchemaDumperTestSqlserver < ActiveRecord::TestCase
-  
-  setup :find_all_tables
-  
-  context 'For primary keys' do
-
-    should 'honor nonstandards' do
-      table_dump('movies') do |output|
-        match = output.match(%r{create_table "movies"(.*)do})
-        assert_not_nil(match, "nonstandardpk table not found")
-        assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
-      end
-    end
-    
-  end
-  
-  context 'For integers' do
-    
-    should 'include limit constraint that match logic for smallint and bigint in #extract_limit' do
-      table_dump('integer_limits') do |output|
-        assert_match %r{c_int_1.*:limit => 2}, output
-        assert_match %r{c_int_2.*:limit => 2}, output
-        assert_match %r{c_int_3.*}, output
-        assert_match %r{c_int_4.*}, output
-        assert_no_match %r{c_int_3.*:limit}, output
-        assert_no_match %r{c_int_4.*:limit}, output
-        assert_match %r{c_int_5.*:limit => 8}, output
-        assert_match %r{c_int_6.*:limit => 8}, output
-        assert_match %r{c_int_7.*:limit => 8}, output
-        assert_match %r{c_int_8.*:limit => 8}, output
-      end
-    end
-    
-  end
-  
-  context 'For strings' do
-
-    should 'have varchar(max) dumped as text' do
-      table_dump('sql_server_strings') do |output|
-        assert_match %r{t.text.*varchar_max}, output
-      end
-    end if sqlserver_2005? || sqlserver_2008?
-
-  end
-  
-  
-  
-  
-  private
-  
-  def find_all_tables
-    @all_tables ||= ActiveRecord::Base.connection.tables
-  end
-  
-  def standard_dump(ignore_tables = [])
-    stream = StringIO.new
-    ActiveRecord::SchemaDumper.ignore_tables = [*ignore_tables]
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-    stream.string
-  end
-  
-  def table_dump(*table_names)
-    stream = StringIO.new
-    ActiveRecord::SchemaDumper.ignore_tables = @all_tables-table_names
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-    yield stream.string
-    stream.string
-  end
-  
-end

data/test/cases/specific_schema_test_sqlserver.rb

@@ -1,97 +0,0 @@
-require 'cases/sqlserver_helper'
-
-class StringDefault < ActiveRecord::Base; end;
-class SqlServerEdgeSchema < ActiveRecord::Base; end;
-
-class SpecificSchemaTestSqlserver < ActiveRecord::TestCase
-  
-  should 'cope with multi line defaults' do
-    default = StringDefault.new
-    assert_equal "Some long default with a\nnew line.", default.string_with_multiline_default
-  end
-  
-  should 'default strings before save' do
-    default = StringDefault.new
-    assert_equal nil, default.string_with_null_default
-    assert_equal 'null', default.string_with_pretend_null_one
-    assert_equal '(null)', default.string_with_pretend_null_two
-    assert_equal 'NULL', default.string_with_pretend_null_three
-    assert_equal '(NULL)', default.string_with_pretend_null_four
-    assert_equal '(3)', default.string_with_pretend_paren_three
-  end
-
-  should 'default strings after save' do
-    default = StringDefault.create
-    assert_equal nil, default.string_with_null_default
-    assert_equal 'null', default.string_with_pretend_null_one
-    assert_equal '(null)', default.string_with_pretend_null_two
-    assert_equal 'NULL', default.string_with_pretend_null_three
-    assert_equal '(NULL)', default.string_with_pretend_null_four
-  end
-  
-  context 'Testing edge case schemas' do
-    
-    setup do
-      @edge_class = SqlServerEdgeSchema
-    end
-    
-    context 'with description column' do
-
-      setup do
-        @da = @edge_class.create! :description => 'A'
-        @db = @edge_class.create! :description => 'B'
-        @dc = @edge_class.create! :description => 'C'
-      end
-      
-      teardown { @edge_class.delete_all }
-
-      should 'allow all sorts of ordering without adapter munging it up' do
-        assert_equal ['A','B','C'], @edge_class.all(:order => 'description').map(&:description)
-        assert_equal ['A','B','C'], @edge_class.all(:order => 'description asc').map(&:description)
-        assert_equal ['A','B','C'], @edge_class.all(:order => 'description ASC').map(&:description)
-        assert_equal ['C','B','A'], @edge_class.all(:order => 'description desc').map(&:description)
-        assert_equal ['C','B','A'], @edge_class.all(:order => 'description DESC').map(&:description)
-      end
-
-    end
-    
-    context 'with bigint column' do
-
-      setup do
-        @b5k   = 5000
-        @bi5k  = @edge_class.create! :bigint => @b5k, :description => 'Five Thousand'
-        @bnum  = 9_000_000_000_000_000_000
-        @bimjr = @edge_class.create! :bigint => @bnum, :description => 'Close to max bignum'
-      end
-
-      should 'can find by biginit' do
-        assert_equal @bi5k,  @edge_class.find_by_bigint(@b5k)
-        assert_equal @b5k,   @edge_class.find(:first, :select => 'bigint', :conditions => {:bigint => @b5k}).bigint
-        assert_equal @bimjr, @edge_class.find_by_bigint(@bnum)
-        assert_equal @bnum,  @edge_class.find(:first, :select => 'bigint', :conditions => {:bigint => @bnum}).bigint
-      end
-
-    end
-    
-    context 'with tinyint column' do
-
-      setup do
-        @tiny1 = @edge_class.create! :tinyint => 1
-        @tiny255 = @edge_class.create! :tinyint => 255
-      end
-
-      should 'not treat tinyint like boolean as mysql does' do
-        assert_equal 1, @edge_class.find_by_tinyint(1).tinyint
-        assert_equal 255, @edge_class.find_by_tinyint(255).tinyint
-      end
-      
-      should 'throw an error when going out of our tiny int bounds' do
-        assert_raise(ActiveRecord::StatementInvalid) { @edge_class.create! :tinyint => 256 }
-      end
-      
-    end
-    
-  end
-  
-  
-end