[Rails31] Getting the tests to run with out deprecations for inheritable attributes and new IGNORED_SQL placement.

Author: metaskills

Gemfile

@@ -2,6 +2,8 @@
 source :rubygems
 
 gemspec :path => ENV['RAILS_SOURCE']
+# TODO: [Rails31] Remove this rack hack.
+gem 'rack', :git => 'git://github.com/rack/rack.git'  # master e8563a6 2011-03-30
 gem 'arel', :path => ENV['AREL']
 
 group :tinytds do

lib/active_record/connection_adapters/sqlserver/core_ext/active_record.rb

@@ -1,21 +1,28 @@
+require 'set'
+require 'active_record/base'
 require 'active_record/version'
-require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
   module ConnectionAdapters
     module Sqlserver
       module CoreExt
         module ActiveRecord
-
-          def self.included(klass)
-            klass.extend ClassMethods
-            class << klass
+          
+          extend ActiveSupport::Concern
+          
+          included do
+            class_attribute :coerced_sqlserver_date_columns, :coerced_sqlserver_time_columns
+            self.coerced_sqlserver_date_columns = Set.new
+            self.coerced_sqlserver_time_columns = Set.new
+            class << self
               alias_method_chain :reset_column_information, :sqlserver_cache_support
             end
           end
 
           module ClassMethods
-
+            
             def execute_procedure(proc_name, *variables)
               if connection.respond_to?(:execute_procedure)
                 connection.execute_procedure(proc_name,*variables)
@@ -25,19 +32,11 @@ def execute_procedure(proc_name, *variables)
             end
 
             def coerce_sqlserver_date(*attributes)
-              write_inheritable_attribute :coerced_sqlserver_date_columns, Set.new(attributes.map(&:to_s))
+              self.coerced_sqlserver_date_columns += attributes.map(&:to_s)
             end
 
             def coerce_sqlserver_time(*attributes)
-              write_inheritable_attribute :coerced_sqlserver_time_columns, Set.new(attributes.map(&:to_s))
-            end
-
-            def coerced_sqlserver_date_columns
-              read_inheritable_attribute(:coerced_sqlserver_date_columns) || []
-            end
-
-            def coerced_sqlserver_time_columns
-              read_inheritable_attribute(:coerced_sqlserver_time_columns) || []
+              self.coerced_sqlserver_time_columns += attributes.map(&:to_s)
             end
 
             def reset_column_information_with_sqlserver_cache_support

test/cases/pessimistic_locking_test_sqlserver.rb

@@ -75,49 +75,4 @@ def setup
   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 unless ruby_19?
-    
-  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

test/cases/sqlserver_helper.rb

@@ -79,15 +79,12 @@ def method_added(method)
 
 # Our changes/additions to ActiveRecord test helpers specific for SQL Server.
 
-ActiveRecord::Base.connection.class.class_eval do
-  IGNORED_SQL << %r|SELECT SCOPE_IDENTITY| << %r{INFORMATION_SCHEMA\.(TABLES|VIEWS|COLUMNS)} << 
-                 %r|SELECT @@IDENTITY| << %r|SELECT @@ROWCOUNT| << %r|SELECT @@version| << %r|SELECT @@TRANCOUNT|
-  def raw_select_with_query_record(sql, name=nil, options={})
-    $queries_executed ||= []
-    $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-    raw_select_without_query_record(sql, name, options)
+module ActiveRecord
+  class SQLCounter
+    IGNORED_SQL << %r|SELECT SCOPE_IDENTITY| << %r{INFORMATION_SCHEMA\.(TABLES|VIEWS|COLUMNS)} << 
+                   %r|SELECT @@IDENTITY| << %r|SELECT @@ROWCOUNT| << %r|SELECT @@version| << %r|SELECT @@TRANCOUNT|
+    
   end
-  alias_method_chain :raw_select, :query_record
 end
 
 module ActiveRecord 
@@ -101,16 +98,6 @@ def sqlserver_2008? ; ActiveRecord::Base.connection.sqlserver_2008? ; end
       def sqlserver_azure? ; ActiveRecord::Base.connection.sqlserver_azure? ; end
       def ruby_19? ; RUBY_VERSION >= '1.9' ; end
     end
-    def assert_sql(*patterns_to_match)
-      $queries_executed = []
-      yield
-    ensure
-      failed_patterns = []
-      patterns_to_match.each do |pattern|
-        failed_patterns << pattern unless $queries_executed.any?{ |sql| pattern === sql }
-      end
-      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map{ |p| p.inspect }.join(', ')} not found.#{$queries_executed.size == 0 ? '' : "\nQueries:\n#{$queries_executed.join("\n")}"}"
-    end
     def connection_mode_dblib? ; self.class.connection_mode_dblib? ; end
     def connection_mode_odbc? ; self.class.connection_mode_odbc? ; end
     def connection_mode_adonet? ; self.class.connection_mode_adonet? ; end