Merge branch 'master' of https://github.com/rails/rails into performance_test

27 files changed, 817 insertions, 381 deletions

diff --git a/activerecord/test/cases/adapters/mysql/connection_test.rb b/activerecord/test/cases/adapters/mysql/connection_test.rb
index eb3f8143e7..eee771ecff 100644
--- a/activerecord/test/cases/adapters/mysql/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql/connection_test.rb
@@ -44,7 +44,7 @@ class MysqlConnectionTest < ActiveRecord::TestCase
   end
 
   def test_bind_value_substitute
-    bind_param = @connection.substitute_for('foo', [])
+    bind_param = @connection.substitute_at('foo', 0)
     assert_equal Arel.sql('?'), bind_param
   end
 
diff --git a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
new file mode 100644
index 0000000000..146b77a95c
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlAdapterTest < ActiveRecord::TestCase
+      def setup
+        @conn = ActiveRecord::Base.connection
+        @conn.exec_query('drop table if exists ex')
+        @conn.exec_query(<<-eosql)
+          CREATE TABLE `ex` (
+            `id` int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+            `number` integer,
+            `data` varchar(255))
+        eosql
+      end
+
+      def test_client_encoding
+        if "<3".respond_to?(:encoding)
+          assert_equal Encoding::UTF_8, @conn.client_encoding
+        else
+          assert_equal 'utf8', @conn.client_encoding
+        end
+      end
+
+      def test_exec_insert_number
+        insert(@conn, 'number' => 10)
+
+        result = @conn.exec_query('SELECT number FROM ex WHERE number = 10')
+
+        assert_equal 1, result.rows.length
+        assert_equal 10, result.rows.last.last
+      end
+
+      def test_exec_insert_string
+        str = 'いただきます！'
+        insert(@conn, 'number' => 10, 'data' => str)
+
+        result = @conn.exec_query('SELECT number, data FROM ex WHERE number = 10')
+
+        value = result.rows.last.last
+
+        if "<3".respond_to?(:encoding)
+          # FIXME: this should probably be inside the mysql AR adapter?
+          value.force_encoding(@conn.client_encoding)
+
+          # The strings in this file are utf-8, so transcode to utf-8
+          value.encode!(Encoding::UTF_8)
+        end
+
+        assert_equal str, value
+      end
+
+      private
+      def insert(ctx, data)
+        binds   = data.map { |name, value|
+          [ctx.columns('ex').find { |x| x.name == name }, value]
+        }
+        columns = binds.map(&:first).map(&:name)
+
+        sql = "INSERT INTO ex (#{columns.join(", ")})
+               VALUES (#{(['?'] * columns.length).join(', ')})"
+
+        ctx.exec_insert(sql, 'SQL', binds)
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql/quoting_test.rb b/activerecord/test/cases/adapters/mysql/quoting_test.rb
new file mode 100644
index 0000000000..9673e2bb46
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql/quoting_test.rb
@@ -0,0 +1,26 @@
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlAdapter
+      class QuotingTest < ActiveRecord::TestCase
+        def setup
+          @conn = ActiveRecord::Base.connection
+        end
+
+        def test_type_cast_true
+          c = Column.new(nil, 1, 'boolean')
+          assert_equal 1, @conn.type_cast(true, nil)
+          assert_equal 1, @conn.type_cast(true, c)
+        end
+
+        def test_type_cast_false
+          c = Column.new(nil, 1, 'boolean')
+          assert_equal 0, @conn.type_cast(false, nil)
+          assert_equal 0, @conn.type_cast(false, c)
+        end
+      end
+    end
+  end
+end
+
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index b0a4a4e39d..7c49236854 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -1,3 +1,4 @@
+# encoding: utf-8
 require "cases/helper"
 
 module ActiveRecord
@@ -6,7 +7,52 @@ module ActiveRecord
       def setup
         @connection = ActiveRecord::Base.connection
         @connection.exec_query('drop table if exists ex')
-        @connection.exec_query('create table ex(id serial primary key, data character varying(255))')
+        @connection.exec_query('create table ex(id serial primary key, number integer, data character varying(255))')
+      end
+
+      def test_serial_sequence
+        assert_equal 'public.accounts_id_seq',
+          @connection.serial_sequence('accounts', 'id')
+
+        assert_raises(ActiveRecord::StatementInvalid) do
+          @connection.serial_sequence('zomg', 'id')
+        end
+      end
+
+      def test_default_sequence_name
+        assert_equal 'accounts_id_seq',
+          @connection.default_sequence_name('accounts', 'id')
+
+        assert_equal 'accounts_id_seq',
+          @connection.default_sequence_name('accounts')
+      end
+
+      def test_default_sequence_name_bad_table
+        assert_equal 'zomg_id_seq',
+          @connection.default_sequence_name('zomg', 'id')
+
+        assert_equal 'zomg_id_seq',
+          @connection.default_sequence_name('zomg')
+      end
+
+      def test_exec_insert_number
+        insert(@connection, 'number' => 10)
+
+        result = @connection.exec_query('SELECT number FROM ex WHERE number = 10')
+
+        assert_equal 1, result.rows.length
+        assert_equal "10", result.rows.last.last
+      end
+
+      def test_exec_insert_string
+        str = 'いただきます！'
+        insert(@connection, 'number' => 10, 'data' => str)
+
+        result = @connection.exec_query('SELECT number, data FROM ex WHERE number = 10')
+
+        value = result.rows.last.last
+
+        assert_equal str, value
       end
 
       def test_table_alias_length
@@ -56,13 +102,28 @@ module ActiveRecord
         assert_equal [['1', 'foo']], result.rows
       end
 
-      def test_substitute_for
-        bind = @connection.substitute_for(nil, [])
+      def test_substitute_at
+        bind = @connection.substitute_at(nil, 0)
         assert_equal Arel.sql('$1'), bind
 
-        bind = @connection.substitute_for(nil, [nil])
+        bind = @connection.substitute_at(nil, 1)
         assert_equal Arel.sql('$2'), bind
       end
+
+      private
+      def insert(ctx, data)
+        binds   = data.map { |name, value|
+          [ctx.columns('ex').find { |x| x.name == name }, value]
+        }
+        columns = binds.map(&:first).map(&:name)
+
+        bind_subs = columns.length.times.map { |x| "$#{x + 1}" }
+
+        sql = "INSERT INTO ex (#{columns.join(", ")})
+               VALUES (#{bind_subs.join(', ')})"
+
+        ctx.exec_insert(sql, 'SQL', binds)
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
new file mode 100644
index 0000000000..172055f15c
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -0,0 +1,25 @@
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      class QuotingTest < ActiveRecord::TestCase
+        def setup
+          @conn = ActiveRecord::Base.connection
+        end
+
+        def test_type_cast_true
+          c = Column.new(nil, 1, 'boolean')
+          assert_equal 't', @conn.type_cast(true, nil)
+          assert_equal 't', @conn.type_cast(true, c)
+        end
+
+        def test_type_cast_false
+          c = Column.new(nil, 1, 'boolean')
+          assert_equal 'f', @conn.type_cast(false, nil)
+          assert_equal 'f', @conn.type_cast(false, c)
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb b/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb
deleted file mode 100644
index d1fc470907..0000000000
--- a/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb
+++ /dev/null
@@ -1,229 +0,0 @@
-# encoding: utf-8
-require "cases/helper"
-require 'models/binary'
-
-module ActiveRecord
-  module ConnectionAdapters
-    class SQLiteAdapterTest < ActiveRecord::TestCase
-      class DualEncoding < ActiveRecord::Base
-      end
-
-      def setup
-        @ctx = Base.sqlite3_connection :database => ':memory:',
-                                      :adapter => 'sqlite3',
-                                      :timeout => nil
-        @ctx.execute <<-eosql
-          CREATE TABLE items (
-            id integer PRIMARY KEY AUTOINCREMENT,
-            number integer
-          )
-        eosql
-      end
-
-      def test_quote_binary_column_escapes_it
-        DualEncoding.connection.execute(<<-eosql)
-          CREATE TABLE dual_encodings (
-            id integer PRIMARY KEY AUTOINCREMENT,
-            name string,
-            data binary
-          )
-        eosql
-        str = "\x80".force_encoding("ASCII-8BIT")
-        binary = DualEncoding.new :name => 'いただきます！', :data => str
-        binary.save!
-        assert_equal str, binary.data
-      end
-
-      def test_execute
-        @ctx.execute "INSERT INTO items (number) VALUES (10)"
-        records = @ctx.execute "SELECT * FROM items"
-        assert_equal 1, records.length
-
-        record = records.first
-        assert_equal 10, record['number']
-        assert_equal 1, record['id']
-      end
-
-      def test_quote_string
-        assert_equal "''", @ctx.quote_string("'")
-      end
-
-      def test_insert_sql
-        2.times do |i|
-          rv = @ctx.insert_sql "INSERT INTO items (number) VALUES (#{i})"
-          assert_equal(i + 1, rv)
-        end
-
-        records = @ctx.execute "SELECT * FROM items"
-        assert_equal 2, records.length
-      end
-
-      def test_insert_sql_logged
-        sql = "INSERT INTO items (number) VALUES (10)"
-        name = "foo"
-
-        assert_logged([[sql, name]]) do
-          @ctx.insert_sql sql, name
-        end
-      end
-
-      def test_insert_id_value_returned
-        sql = "INSERT INTO items (number) VALUES (10)"
-        idval = 'vuvuzela'
-        id = @ctx.insert_sql sql, nil, nil, idval
-        assert_equal idval, id
-      end
-
-      def test_select_rows
-        2.times do |i|
-          @ctx.create "INSERT INTO items (number) VALUES (#{i})"
-        end
-        rows = @ctx.select_rows 'select number, id from items'
-        assert_equal [[0, 1], [1, 2]], rows
-      end
-
-      def test_select_rows_logged
-        sql = "select * from items"
-        name = "foo"
-
-        assert_logged([[sql, name]]) do
-          @ctx.select_rows sql, name
-        end
-      end
-
-      def test_transaction
-        count_sql = 'select count(*) from items'
-
-        @ctx.begin_db_transaction
-        @ctx.create "INSERT INTO items (number) VALUES (10)"
-
-        assert_equal 1, @ctx.select_rows(count_sql).first.first
-        @ctx.rollback_db_transaction
-        assert_equal 0, @ctx.select_rows(count_sql).first.first
-      end
-
-      def test_tables
-        assert_equal %w{ items }, @ctx.tables
-
-        @ctx.execute <<-eosql
-          CREATE TABLE people (
-            id integer PRIMARY KEY AUTOINCREMENT,
-            number integer
-          )
-        eosql
-        assert_equal %w{ items people }.sort, @ctx.tables.sort
-      end
-
-      def test_tables_logs_name
-        name = "hello"
-        assert_logged [[name]] do
-          @ctx.tables(name)
-          assert_not_nil @ctx.logged.first.shift
-        end
-      end
-
-      def test_columns
-        columns = @ctx.columns('items').sort_by { |x| x.name }
-        assert_equal 2, columns.length
-        assert_equal %w{ id number }.sort, columns.map { |x| x.name }
-        assert_equal [nil, nil], columns.map { |x| x.default }
-        assert_equal [true, true], columns.map { |x| x.null }
-      end
-
-      def test_columns_with_default
-        @ctx.execute <<-eosql
-          CREATE TABLE columns_with_default (
-            id integer PRIMARY KEY AUTOINCREMENT,
-            number integer default 10
-          )
-        eosql
-        column = @ctx.columns('columns_with_default').find { |x|
-          x.name == 'number'
-        }
-        assert_equal 10, column.default
-      end
-
-      def test_columns_with_not_null
-        @ctx.execute <<-eosql
-          CREATE TABLE columns_with_default (
-            id integer PRIMARY KEY AUTOINCREMENT,
-            number integer not null
-          )
-        eosql
-        column = @ctx.columns('columns_with_default').find { |x|
-          x.name == 'number'
-        }
-        assert !column.null, "column should not be null"
-      end
-
-      def test_indexes_logs
-        intercept_logs_on @ctx
-        assert_difference('@ctx.logged.length') do
-          @ctx.indexes('items')
-        end
-        assert_match(/items/, @ctx.logged.last.first)
-      end
-
-      def test_no_indexes
-        assert_equal [], @ctx.indexes('items')
-      end
-
-      def test_index
-        @ctx.add_index 'items', 'id', :unique => true, :name => 'fun'
-        index = @ctx.indexes('items').find { |idx| idx.name == 'fun' }
-
-        assert_equal 'items', index.table
-        assert index.unique, 'index is unique'
-        assert_equal ['id'], index.columns
-      end
-
-      def test_non_unique_index
-        @ctx.add_index 'items', 'id', :name => 'fun'
-        index = @ctx.indexes('items').find { |idx| idx.name == 'fun' }
-        assert !index.unique, 'index is not unique'
-      end
-
-      def test_compound_index
-        @ctx.add_index 'items', %w{ id number }, :name => 'fun'
-        index = @ctx.indexes('items').find { |idx| idx.name == 'fun' }
-        assert_equal %w{ id number }.sort, index.columns.sort
-      end
-
-      def test_primary_key
-        assert_equal 'id', @ctx.primary_key('items')
-
-        @ctx.execute <<-eosql
-          CREATE TABLE foos (
-            internet integer PRIMARY KEY AUTOINCREMENT,
-            number integer not null
-          )
-        eosql
-        assert_equal 'internet', @ctx.primary_key('foos')
-      end
-
-      def test_no_primary_key
-        @ctx.execute 'CREATE TABLE failboat (number integer not null)'
-        assert_nil @ctx.primary_key('failboat')
-      end
-
-      private
-
-      def assert_logged logs
-        intercept_logs_on @ctx
-        yield
-        assert_equal logs, @ctx.logged
-      end
-
-      def intercept_logs_on ctx
-        @ctx.extend(Module.new {
-          attr_accessor :logged
-          def log sql, name
-            @logged << [sql, name]
-            yield
-          end
-        })
-        @ctx.logged = []
-      end
-    end
-  end
-end
diff --git a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
new file mode 100644
index 0000000000..0d9db92447
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
@@ -0,0 +1,93 @@
+require "cases/helper"
+require 'bigdecimal'
+require 'yaml'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLiteAdapter
+      class QuotingTest < ActiveRecord::TestCase
+        def setup
+          @conn = Base.sqlite3_connection :database => ':memory:',
+            :adapter => 'sqlite3',
+            :timeout => 100
+        end
+
+        def test_type_cast_symbol
+          assert_equal 'foo', @conn.type_cast(:foo, nil)
+        end
+
+        def test_type_cast_date
+          date = Date.today
+          expected = @conn.quoted_date(date)
+          assert_equal expected, @conn.type_cast(date, nil)
+        end
+
+        def test_type_cast_time
+          time = Time.now
+          expected = @conn.quoted_date(time)
+          assert_equal expected, @conn.type_cast(time, nil)
+        end
+
+        def test_type_cast_numeric
+          assert_equal 10, @conn.type_cast(10, nil)
+          assert_equal 2.2, @conn.type_cast(2.2, nil)
+        end
+
+        def test_type_cast_nil
+          assert_equal nil, @conn.type_cast(nil, nil)
+        end
+
+        def test_type_cast_true
+          c = Column.new(nil, 1, 'int')
+          assert_equal 't', @conn.type_cast(true, nil)
+          assert_equal 1, @conn.type_cast(true, c)
+        end
+
+        def test_type_cast_false
+          c = Column.new(nil, 1, 'int')
+          assert_equal 'f', @conn.type_cast(false, nil)
+          assert_equal 0, @conn.type_cast(false, c)
+        end
+
+        def test_type_cast_string
+          assert_equal '10', @conn.type_cast('10', nil)
+
+          c = Column.new(nil, 1, 'int')
+          assert_equal 10, @conn.type_cast('10', c)
+
+          c = Column.new(nil, 1, 'float')
+          assert_equal 10.1, @conn.type_cast('10.1', c)
+
+          c = Column.new(nil, 1, 'binary')
+          assert_equal '10.1', @conn.type_cast('10.1', c)
+
+          c = Column.new(nil, 1, 'date')
+          assert_equal '10.1', @conn.type_cast('10.1', c)
+        end
+
+        def test_type_cast_bigdecimal
+          bd = BigDecimal.new '10.0'
+          assert_equal bd.to_s('F'), @conn.type_cast(bd, nil)
+        end
+
+        def test_type_cast_unknown
+          obj = Class.new.new
+          assert_equal YAML.dump(obj), @conn.type_cast(obj, nil)
+        end
+
+        def test_quoted_id
+          quoted_id_obj = Class.new {
+            def quoted_id
+              "'zomg'"
+            end
+
+            def id
+              10
+            end
+          }.new
+          assert_equal 10, @conn.type_cast(quoted_id_obj, nil)
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index b8abdface4..6ff04e3eb3 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -1,12 +1,34 @@
+# encoding: utf-8
 require "cases/helper"
 
 module ActiveRecord
   module ConnectionAdapters
     class SQLite3AdapterTest < ActiveRecord::TestCase
+      class DualEncoding < ActiveRecord::Base
+      end
+
       def setup
         @conn = Base.sqlite3_connection :database => ':memory:',
                                        :adapter => 'sqlite3',
                                        :timeout => 100
+        @conn.execute <<-eosql
+          CREATE TABLE items (
+            id integer PRIMARY KEY AUTOINCREMENT,
+            number integer
+          )
+        eosql
+      end
+
+      def test_exec_insert
+        column = @conn.columns('items').find { |col| col.name == 'number' }
+        vals   = [[column, 10]]
+        @conn.exec_insert('insert into items (number) VALUES (?)', 'SQL', vals)
+
+        result = @conn.exec_query(
+          'select number from items where number = ?', 'SQL', vals)
+
+        assert_equal 1, result.rows.length
+        assert_equal 10, result.rows.first.first
       end
 
       def test_primary_key_returns_nil_for_no_pk
@@ -58,7 +80,7 @@ module ActiveRecord
       end
 
       def test_bind_value_substitute
-        bind_param = @conn.substitute_for('foo', [])
+        bind_param = @conn.substitute_at('foo', 0)
         assert_equal Arel.sql('?'), bind_param
       end
 
@@ -102,6 +124,213 @@ module ActiveRecord
 
         assert_equal [[1, 'foo']], result.rows
       end
+
+      def test_quote_binary_column_escapes_it
+        return unless "<3".respond_to?(:encode)
+
+        DualEncoding.connection.execute(<<-eosql)
+          CREATE TABLE dual_encodings (
+            id integer PRIMARY KEY AUTOINCREMENT,
+            name string,
+            data binary
+          )
+        eosql
+        str = "\x80".force_encoding("ASCII-8BIT")
+        binary = DualEncoding.new :name => 'いただきます！', :data => str
+        binary.save!
+        assert_equal str, binary.data
+      end
+
+      def test_execute
+        @conn.execute "INSERT INTO items (number) VALUES (10)"
+        records = @conn.execute "SELECT * FROM items"
+        assert_equal 1, records.length
+
+        record = records.first
+        assert_equal 10, record['number']
+        assert_equal 1, record['id']
+      end
+
+      def test_quote_string
+        assert_equal "''", @conn.quote_string("'")
+      end
+
+      def test_insert_sql
+        2.times do |i|
+          rv = @conn.insert_sql "INSERT INTO items (number) VALUES (#{i})"
+          assert_equal(i + 1, rv)
+        end
+
+        records = @conn.execute "SELECT * FROM items"
+        assert_equal 2, records.length
+      end
+
+      def test_insert_sql_logged
+        sql = "INSERT INTO items (number) VALUES (10)"
+        name = "foo"
+
+        assert_logged([[sql, name, []]]) do
+          @conn.insert_sql sql, name
+        end
+      end
+
+      def test_insert_id_value_returned
+        sql = "INSERT INTO items (number) VALUES (10)"
+        idval = 'vuvuzela'
+        id = @conn.insert_sql sql, nil, nil, idval
+        assert_equal idval, id
+      end
+
+      def test_select_rows
+        2.times do |i|
+          @conn.create "INSERT INTO items (number) VALUES (#{i})"
+        end
+        rows = @conn.select_rows 'select number, id from items'
+        assert_equal [[0, 1], [1, 2]], rows
+      end
+
+      def test_select_rows_logged
+        sql = "select * from items"
+        name = "foo"
+
+        assert_logged([[sql, name, []]]) do
+          @conn.select_rows sql, name
+        end
+      end
+
+      def test_transaction
+        count_sql = 'select count(*) from items'
+
+        @conn.begin_db_transaction
+        @conn.create "INSERT INTO items (number) VALUES (10)"
+
+        assert_equal 1, @conn.select_rows(count_sql).first.first
+        @conn.rollback_db_transaction
+        assert_equal 0, @conn.select_rows(count_sql).first.first
+      end
+
+      def test_tables
+        assert_equal %w{ items }, @conn.tables
+
+        @conn.execute <<-eosql
+          CREATE TABLE people (
+            id integer PRIMARY KEY AUTOINCREMENT,
+            number integer
+          )
+        eosql
+        assert_equal %w{ items people }.sort, @conn.tables.sort
+      end
+
+      def test_tables_logs_name
+        name = "hello"
+        assert_logged [[name, []]] do
+          @conn.tables(name)
+          assert_not_nil @conn.logged.first.shift
+        end
+      end
+
+      def test_columns
+        columns = @conn.columns('items').sort_by { |x| x.name }
+        assert_equal 2, columns.length
+        assert_equal %w{ id number }.sort, columns.map { |x| x.name }
+        assert_equal [nil, nil], columns.map { |x| x.default }
+        assert_equal [true, true], columns.map { |x| x.null }
+      end
+
+      def test_columns_with_default
+        @conn.execute <<-eosql
+          CREATE TABLE columns_with_default (
+            id integer PRIMARY KEY AUTOINCREMENT,
+            number integer default 10
+          )
+        eosql
+        column = @conn.columns('columns_with_default').find { |x|
+          x.name == 'number'
+        }
+        assert_equal 10, column.default
+      end
+
+      def test_columns_with_not_null
+        @conn.execute <<-eosql
+          CREATE TABLE columns_with_default (
+            id integer PRIMARY KEY AUTOINCREMENT,
+            number integer not null
+          )
+        eosql
+        column = @conn.columns('columns_with_default').find { |x|
+          x.name == 'number'
+        }
+        assert !column.null, "column should not be null"
+      end
+
+      def test_indexes_logs
+        intercept_logs_on @conn
+        assert_difference('@conn.logged.length') do
+          @conn.indexes('items')
+        end
+        assert_match(/items/, @conn.logged.last.first)
+      end
+
+      def test_no_indexes
+        assert_equal [], @conn.indexes('items')
+      end
+
+      def test_index
+        @conn.add_index 'items', 'id', :unique => true, :name => 'fun'
+        index = @conn.indexes('items').find { |idx| idx.name == 'fun' }
+
+        assert_equal 'items', index.table
+        assert index.unique, 'index is unique'
+        assert_equal ['id'], index.columns
+      end
+
+      def test_non_unique_index
+        @conn.add_index 'items', 'id', :name => 'fun'
+        index = @conn.indexes('items').find { |idx| idx.name == 'fun' }
+        assert !index.unique, 'index is not unique'
+      end
+
+      def test_compound_index
+        @conn.add_index 'items', %w{ id number }, :name => 'fun'
+        index = @conn.indexes('items').find { |idx| idx.name == 'fun' }
+        assert_equal %w{ id number }.sort, index.columns.sort
+      end
+
+      def test_primary_key
+        assert_equal 'id', @conn.primary_key('items')
+
+        @conn.execute <<-eosql
+          CREATE TABLE foos (
+            internet integer PRIMARY KEY AUTOINCREMENT,
+            number integer not null
+          )
+        eosql
+        assert_equal 'internet', @conn.primary_key('foos')
+      end
+
+      def test_no_primary_key
+        @conn.execute 'CREATE TABLE failboat (number integer not null)'
+        assert_nil @conn.primary_key('failboat')
+      end
+
+      private
+
+      def assert_logged logs
+        intercept_logs_on @conn
+        yield
+        assert_equal logs, @conn.logged
+      end
+
+      def intercept_logs_on ctx
+        @conn.extend(Module.new {
+          attr_accessor :logged
+          def log sql, name, binds = []
+            @logged << [sql, name, binds]
+            yield
+          end
+        })
+        @conn.logged = []
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 16d4877fe8..007f11b535 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -70,16 +70,16 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   # would be convenient), because this would cause that scope to be applied to any callbacks etc.
   def test_build_and_create_should_not_happen_within_scope
     car = cars(:honda)
-    original_scoped_methods = Bulb.scoped_methods
+    scoped_count = car.foo_bulbs.scoped.where_values.count
 
-    bulb = car.bulbs.build
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = car.foo_bulbs.build
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
 
-    bulb = car.bulbs.create
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = car.foo_bulbs.create
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
 
-    bulb = car.bulbs.create!
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = car.foo_bulbs.create!
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
   end
 
   def test_no_sql_should_be_fired_if_association_already_loaded
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index c1dad5e246..f3c96ccbe6 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -165,16 +165,16 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_build_and_create_should_not_happen_within_scope
     pirate = pirates(:blackbeard)
-    original_scoped_methods = Bulb.scoped_methods.dup
+    scoped_count = pirate.association(:foo_bulb).scoped.where_values.count
 
-    bulb = pirate.build_bulb
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = pirate.build_foo_bulb
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
 
-    bulb = pirate.create_bulb
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = pirate.create_foo_bulb
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
 
-    bulb = pirate.create_bulb!
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = pirate.create_foo_bulb!
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
   end
 
   def test_create_association
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 5a7b139030..49a1c117bc 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -1,4 +1,5 @@
 require "cases/helper"
+require 'active_support/core_ext/object/inclusion'
 require 'models/tag'
 require 'models/tagging'
 require 'models/post'
@@ -453,7 +454,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert saved_post.tags.include?(new_tag)
 
     assert new_tag.persisted?
-    assert saved_post.reload.tags(true).include?(new_tag)
+    assert new_tag.in?(saved_post.reload.tags(true))
 
 
     new_post = Post.new(:title => "Association replacmenet works!", :body => "You best believe it.")
@@ -466,7 +467,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
     new_post.save!
     assert new_post.persisted?
-    assert new_post.reload.tags(true).include?(saved_tag)
+    assert saved_tag.in?(new_post.reload.tags(true))
 
     assert !posts(:thinking).tags.build.persisted?
     assert !posts(:thinking).tags.new.persisted?
@@ -515,10 +516,10 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_collection_size_uses_counter_cache_if_it_exists
-    author = authors(:david)
-    author.stubs(:_read_attribute).with('comments_count').returns(100)
-    assert_equal 100, author.comments.size
-    assert !author.comments.loaded?
+    c = categories(:general)
+    c.categorizations_count = 100
+    assert_equal 100, c.categorizations.size
+    assert !c.categorizations.loaded?
   end
 
   def test_adding_junk_to_has_many_through_should_raise_type_mismatch
diff --git a/activerecord/test/cases/attribute_methods/read_test.rb b/activerecord/test/cases/attribute_methods/read_test.rb
index d0a9028264..3641031d12 100644
--- a/activerecord/test/cases/attribute_methods/read_test.rb
+++ b/activerecord/test/cases/attribute_methods/read_test.rb
@@ -1,4 +1,5 @@
 require "cases/helper"
+require 'active_support/core_ext/object/inclusion'
 
 module ActiveRecord
   module AttributeMethods
@@ -41,13 +42,13 @@ module ActiveRecord
         instance = @klass.new
 
         @klass.column_names.each do |name|
-          assert ! instance.methods.map(&:to_s).include?(name)
+          assert !name.in?(instance.methods.map(&:to_s))
         end
 
         @klass.define_attribute_methods
 
         @klass.column_names.each do |name|
-          assert(instance.methods.map(&:to_s).include?(name), "#{name} is not defined")
+          assert name.in?(instance.methods.map(&:to_s)), "#{name} is not defined"
         end
       end
 
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 84f75cc803..5074ae50ab 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -1,4 +1,5 @@
 require "cases/helper"
+require 'active_support/core_ext/object/inclusion'
 require 'models/minimalistic'
 require 'models/developer'
 require 'models/auto_id'
@@ -9,6 +10,7 @@ require 'models/company'
 require 'models/category'
 require 'models/reply'
 require 'models/contact'
+require 'models/keyboard'
 
 class AttributeMethodsTest < ActiveRecord::TestCase
   fixtures :topics, :developers, :companies, :computers
@@ -76,6 +78,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   def test_respond_to?
     topic = Topic.find(1)
     assert_respond_to topic, "title"
+    assert_respond_to topic, "_title"
     assert_respond_to topic, "title?"
     assert_respond_to topic, "title="
     assert_respond_to topic, :title
@@ -87,6 +90,16 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert !topic.respond_to?(:nothingness)
   end
 
+  def test_respond_to_with_custom_primary_key
+    keyboard = Keyboard.create
+    assert_not_nil keyboard.key_number
+    assert_equal keyboard.key_number, keyboard.id
+    assert keyboard.respond_to?('key_number')
+    assert keyboard.respond_to?('_key_number')
+    assert keyboard.respond_to?('id')
+    assert keyboard.respond_to?('_id')
+  end
+
   # Syck calls respond_to? before actually calling initialize
   def test_respond_to_with_allocated_object
     topic = Topic.allocate
@@ -638,7 +651,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   end
 
   def time_related_columns_on_topic
-    Topic.columns.select { |c| [:time, :date, :datetime, :timestamp].include?(c.type) }
+    Topic.columns.select { |c| c.type.in?([:time, :date, :datetime, :timestamp]) }
   end
 
   def serialized_columns_on_topic
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index aeb0b28bab..e57c5b3b87 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -172,7 +172,7 @@ class BasicsTest < ActiveRecord::TestCase
       with_active_record_default_timezone :utc do
         time = Time.local(2000)
         topic = Topic.create('written_on' => time)
-        saved_time = Topic.find(topic.id).written_on
+        saved_time = Topic.find(topic.id).reload.written_on
         assert_equal time, saved_time
         assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "EST"], time.to_a
         assert_equal [0, 0, 5, 1, 1, 2000, 6, 1, false, "UTC"], saved_time.to_a
@@ -186,7 +186,7 @@ class BasicsTest < ActiveRecord::TestCase
         Time.use_zone 'Central Time (US & Canada)' do
           time = Time.zone.local(2000)
           topic = Topic.create('written_on' => time)
-          saved_time = Topic.find(topic.id).written_on
+          saved_time = Topic.find(topic.id).reload.written_on
           assert_equal time, saved_time
           assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "CST"], time.to_a
           assert_equal [0, 0, 6, 1, 1, 2000, 6, 1, false, "UTC"], saved_time.to_a
@@ -199,7 +199,7 @@ class BasicsTest < ActiveRecord::TestCase
     with_env_tz 'America/New_York' do
       time = Time.utc(2000)
       topic = Topic.create('written_on' => time)
-      saved_time = Topic.find(topic.id).written_on
+      saved_time = Topic.find(topic.id).reload.written_on
       assert_equal time, saved_time
       assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "UTC"], time.to_a
       assert_equal [0, 0, 19, 31, 12, 1999, 5, 365, false, "EST"], saved_time.to_a
@@ -212,7 +212,7 @@ class BasicsTest < ActiveRecord::TestCase
         Time.use_zone 'Central Time (US & Canada)' do
           time = Time.zone.local(2000)
           topic = Topic.create('written_on' => time)
-          saved_time = Topic.find(topic.id).written_on
+          saved_time = Topic.find(topic.id).reload.written_on
           assert_equal time, saved_time
           assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "CST"], time.to_a
           assert_equal [0, 0, 1, 1, 1, 2000, 6, 1, false, "EST"], saved_time.to_a
@@ -1048,7 +1048,7 @@ class BasicsTest < ActiveRecord::TestCase
     topic = Topic.new(:content => myobj)
     assert topic.save
     Topic.serialize(:content, Hash)
-    assert_raise(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).content }
+    assert_raise(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).reload.content }
   ensure
     Topic.serialize(:content)
   end
@@ -1626,18 +1626,14 @@ class BasicsTest < ActiveRecord::TestCase
     assert_not_equal c1, c2
   end
 
-  def test_default_scope_is_reset
+  def test_current_scope_is_reset
     Object.const_set :UnloadablePost, Class.new(ActiveRecord::Base)
-    UnloadablePost.table_name = 'posts'
-    UnloadablePost.class_eval do
-      default_scope order('posts.comments_count ASC')
-    end
-    UnloadablePost.scoped_methods # make Thread.current[:UnloadablePost_scoped_methods] not nil
+    UnloadablePost.send(:current_scope=, UnloadablePost.scoped)
 
     UnloadablePost.unloadable
-    assert_not_nil Thread.current[:UnloadablePost_scoped_methods]
+    assert_not_nil Thread.current[:UnloadablePost_current_scope]
     ActiveSupport::Dependencies.remove_unloadable_constants!
-    assert_nil Thread.current[:UnloadablePost_scoped_methods]
+    assert_nil Thread.current[:UnloadablePost_current_scope]
   ensure
     Object.class_eval{ remove_const :UnloadablePost } if defined?(UnloadablePost)
   end
diff --git a/activerecord/test/cases/binary_test.rb b/activerecord/test/cases/binary_test.rb
index 8545ba97cc..06c14cb108 100644
--- a/activerecord/test/cases/binary_test.rb
+++ b/activerecord/test/cases/binary_test.rb
@@ -1,3 +1,4 @@
+# encoding: utf-8
 require "cases/helper"
 
 # Without using prepared statements, it makes no sense to test
@@ -9,6 +10,24 @@ unless current_adapter?(:SybaseAdapter, :DB2Adapter, :FirebirdAdapter)
   class BinaryTest < ActiveRecord::TestCase
     FIXTURES = %w(flowers.jpg example.log)
 
+    def test_mixed_encoding
+      str = "\x80"
+      str.force_encoding('ASCII-8BIT') if str.respond_to?(:force_encoding)
+
+      binary = Binary.new :name => 'いただきます！', :data => str
+      binary.save!
+      binary.reload
+      assert_equal str, binary.data
+
+      name = binary.name
+
+      # Mysql adapter doesn't properly encode things, so we have to do it
+      if current_adapter?(:MysqlAdapter)
+        name.force_encoding('UTF-8') if name.respond_to?(:force_encoding)
+      end
+      assert_equal 'いただきます！', name
+    end
+
     def test_load_save
       Binary.delete_all
 
diff --git a/activerecord/test/cases/bind_parameter_test.rb b/activerecord/test/cases/bind_parameter_test.rb
index 19383bb06b..3652255c38 100644
--- a/activerecord/test/cases/bind_parameter_test.rb
+++ b/activerecord/test/cases/bind_parameter_test.rb
@@ -33,7 +33,7 @@ module ActiveRecord
       # FIXME: use skip with minitest
       return unless @connection.supports_statement_cache?
 
-      sub   = @connection.substitute_for(@pk, [])
+      sub   = @connection.substitute_at(@pk, 0)
       binds = [[@pk, 1]]
       sql   = "select * from topics where id = #{sub}"
 
diff --git a/activerecord/test/cases/defaults_test.rb b/activerecord/test/cases/defaults_test.rb
index deaf5252db..b3a281d960 100644
--- a/activerecord/test/cases/defaults_test.rb
+++ b/activerecord/test/cases/defaults_test.rb
@@ -1,4 +1,5 @@
 require "cases/helper"
+require 'active_support/core_ext/object/inclusion'
 require 'models/default'
 require 'models/entrant'
 
@@ -94,7 +95,7 @@ if current_adapter?(:MysqlAdapter) or current_adapter?(:Mysql2Adapter)
       assert_equal 0, klass.columns_hash['zero'].default
       assert !klass.columns_hash['zero'].null
       # 0 in MySQL 4, nil in 5.
-      assert [0, nil].include?(klass.columns_hash['omit'].default)
+      assert klass.columns_hash['omit'].default.in?([0, nil])
       assert !klass.columns_hash['omit'].null
 
       assert_raise(ActiveRecord::StatementInvalid) { klass.create! }
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 3c242667eb..655437318f 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -247,9 +247,10 @@ class FinderTest < ActiveRecord::TestCase
   def test_find_only_some_columns
     topic = Topic.find(1, :select => "author_name")
     assert_raise(ActiveModel::MissingAttributeError) {topic.title}
+    assert_nil topic.read_attribute("title")
     assert_equal "David", topic.author_name
     assert !topic.attribute_present?("title")
-    #assert !topic.respond_to?("title")
+    assert !topic.attribute_present?(:title)
     assert topic.attribute_present?("author_name")
     assert_respond_to topic, "author_name"
   end
diff --git a/activerecord/test/cases/identity_map_test.rb b/activerecord/test/cases/identity_map_test.rb
index 89f7b92d09..199e59657d 100644
--- a/activerecord/test/cases/identity_map_test.rb
+++ b/activerecord/test/cases/identity_map_test.rb
@@ -90,6 +90,13 @@ class IdentityMapTest < ActiveRecord::TestCase
     )
   end
 
+  def test_queries_are_not_executed_when_finding_by_id
+    Post.find 1
+    assert_no_queries do
+      Post.find 1
+    end
+  end
+
   ##############################################################################
   # Tests checking if IM is functioning properly on more advanced finds        #
   # and associations                                                           #
@@ -144,7 +151,7 @@ class IdentityMapTest < ActiveRecord::TestCase
 
     s = Subscriber.find('swistak')
 
-    assert_equal({'name' => ["Raczkowski Marcin", "Swistak Sreberkowiec"]}, swistak.changes)
+    assert_equal({"name"=>["Marcin Raczkowski", "Swistak Sreberkowiec"]}, swistak.changes)
     assert_equal("Swistak Sreberkowiec", swistak.name)
   end
 
@@ -159,8 +166,8 @@ class IdentityMapTest < ActiveRecord::TestCase
     s = Subscriber.find('swistak')
 
     assert_equal("Swistak Sreberkowiec", swistak.name)
-    assert_equal({}, swistak.changes)
-    assert !swistak.name_changed?
+    assert_equal({"name"=>["Marcin Raczkowski", "Swistak Sreberkowiec"]}, swistak.changes)
+    assert swistak.name_changed?
   end
 
   def test_has_many_associations
@@ -381,6 +388,15 @@ class IdentityMapTest < ActiveRecord::TestCase
     assert_not_nil post.title
   end
 
+  def test_log
+    log = StringIO.new
+    ActiveRecord::Base.logger = Logger.new(log)
+    ActiveRecord::Base.logger.level = Logger::DEBUG
+    Post.find 1
+    Post.find 1
+    assert_match(/Post with ID = 1 loaded from Identity Map/, log.string)
+  end
+
 # Currently AR is not allowing changing primary key (see Persistence#update)
 # So we ignore it. If this changes, this test needs to be uncommented.
 #  def test_updating_of_pkey
diff --git a/activerecord/test/cases/log_subscriber_test.rb b/activerecord/test/cases/log_subscriber_test.rb
index 8ebde933b4..5f55299065 100644
--- a/activerecord/test/cases/log_subscriber_test.rb
+++ b/activerecord/test/cases/log_subscriber_test.rb
@@ -8,6 +8,8 @@ class LogSubscriberTest < ActiveRecord::TestCase
 
   def setup
     @old_logger = ActiveRecord::Base.logger
+    @using_identity_map = ActiveRecord::IdentityMap.enabled?
+    ActiveRecord::IdentityMap.enabled = false
     super
     ActiveRecord::LogSubscriber.attach_to(:active_record)
   end
@@ -16,6 +18,7 @@ class LogSubscriberTest < ActiveRecord::TestCase
     super
     ActiveRecord::LogSubscriber.log_subscribers.pop
     ActiveRecord::Base.logger = @old_logger
+    ActiveRecord::IdentityMap.enabled = @using_identity_map
   end
 
   def set_logger(logger)
diff --git a/activerecord/test/cases/method_scoping_test.rb b/activerecord/test/cases/method_scoping_test.rb
index 7e8383da9e..7f0f007a70 100644
--- a/activerecord/test/cases/method_scoping_test.rb
+++ b/activerecord/test/cases/method_scoping_test.rb
@@ -249,22 +249,21 @@ class MethodScopingTest < ActiveRecord::TestCase
   end
 
   def test_scoped_with_duck_typing
-    scoping = Struct.new(:method_scoping).new(:find => { :conditions => ["name = ?", 'David'] })
+    scoping = Struct.new(:current_scope).new(:find => { :conditions => ["name = ?", 'David'] })
     Developer.send(:with_scope, scoping) do
        assert_equal %w(David), Developer.find(:all).map { |d| d.name }
     end
   end
 
   def test_ensure_that_method_scoping_is_correctly_restored
-    scoped_methods = Developer.instance_eval('current_scoped_methods')
-
     begin
       Developer.send(:with_scope, :find => { :conditions => "name = 'Jamis'" }) do
         raise "an exception"
       end
     rescue
     end
-    assert_equal scoped_methods, Developer.instance_eval('current_scoped_methods')
+
+    assert !Developer.scoped.where_values.include?("name = 'Jamis'")
   end
 end
 
@@ -509,14 +508,15 @@ class NestedScopingTest < ActiveRecord::TestCase
 
   def test_ensure_that_method_scoping_is_correctly_restored
     Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
-      scoped_methods = Developer.instance_eval('current_scoped_methods')
       begin
         Developer.send(:with_scope, :find => { :conditions => "name = 'Maiha'" }) do
           raise "an exception"
         end
       rescue
       end
-      assert_equal scoped_methods, Developer.instance_eval('current_scoped_methods')
+
+      assert Developer.scoped.where_values.include?("name = 'David'")
+      assert !Developer.scoped.where_values.include?("name = 'Maiha'")
     end
   end
 
diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index 9b20ea08de..2880fdc651 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -58,17 +58,6 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert Topic.approved.respond_to?(:tables_in_string, true)
   end
 
-  def test_subclasses_inherit_scopes
-    assert Topic.scopes.include?(:base)
-
-    assert Reply.scopes.include?(:base)
-    assert_equal Reply.find(:all), Reply.base
-  end
-
-  def test_classes_dont_inherit_subclasses_scopes
-    assert !ActiveRecord::Base.scopes.include?(:base)
-  end
-
   def test_scopes_with_options_limit_finds_to_those_matching_the_criteria_specified
     assert !Topic.find(:all, :conditions => {:approved => true}).empty?
 
@@ -440,26 +429,31 @@ class NamedScopeTest < ActiveRecord::TestCase
     end
   end
 
+  # Note: these next two are kinda odd because they are essentially just testing that the
+  # query cache works as it should, but they are here for legacy reasons as they was previously
+  # a separate cache on association proxies, and these show that that is not necessary.
   def test_scopes_are_cached_on_associations
     post = posts(:welcome)
 
-    assert_equal post.comments.containing_the_letter_e.object_id, post.comments.containing_the_letter_e.object_id
-
-    post.comments.containing_the_letter_e.all # force load
-    assert_no_queries { post.comments.containing_the_letter_e.all }
+    Post.cache do
+      assert_queries(1) { post.comments.containing_the_letter_e.all }
+      assert_no_queries { post.comments.containing_the_letter_e.all }
+    end
   end
 
   def test_scopes_with_arguments_are_cached_on_associations
     post = posts(:welcome)
 
-    one = post.comments.limit_by(1).all
-    assert_equal 1, one.size
+    Post.cache do
+      one = assert_queries(1) { post.comments.limit_by(1).all }
+      assert_equal 1, one.size
 
-    two = post.comments.limit_by(2).all
-    assert_equal 2, two.size
+      two = assert_queries(1) { post.comments.limit_by(2).all }
+      assert_equal 2, two.size
 
-    assert_no_queries { post.comments.limit_by(1).all }
-    assert_no_queries { post.comments.limit_by(2).all }
+      assert_no_queries { post.comments.limit_by(1).all }
+      assert_no_queries { post.comments.limit_by(2).all }
+    end
   end
 
   def test_scopes_are_reset_on_association_reload
@@ -477,6 +471,12 @@ class NamedScopeTest < ActiveRecord::TestCase
       require "models/without_table"
     end
   end
+
+  def test_scopes_with_callables_are_deprecated
+    assert_deprecated do
+      Post.scope :WE_SO_EXCITED, lambda { |partyingpartyingpartying, yeah| fun!.fun!.fun! }
+    end
+  end
 end
 
 class DynamicScopeMatchTest < ActiveRecord::TestCase
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index c57ab7ed28..6568eb1d18 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -131,6 +131,14 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     assert_equal 'photography', interest.reload.topic
   end
 
+  def test_destroy_works_independent_of_reject_if
+    Man.accepts_nested_attributes_for :interests, :reject_if => proc {|attributes| true }, :allow_destroy => true
+    man = Man.create(:name => "Jon")
+    interest = man.interests.create(:topic => 'the ladies')
+    man.update_attributes({:interests_attributes => { :_destroy => "1", :id => interest.id } })
+    assert man.reload.interests.empty?
+  end
+
   def test_has_many_association_updating_a_single_record
     Man.accepts_nested_attributes_for(:interests)
     man = Man.create(:name => 'John')
diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index 53aefc7b58..287f7e255b 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -13,7 +13,7 @@ class QueryCacheTest < ActiveRecord::TestCase
   end
 
   def test_find_queries
-    assert_queries(2) { Task.find(1); Task.find(1) }
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) { Task.find(1); Task.find(1) }
   end
 
   def test_find_queries_with_cache
diff --git a/activerecord/test/cases/quoting_test.rb b/activerecord/test/cases/quoting_test.rb
index b87fb51d97..80ee74e41e 100644
--- a/activerecord/test/cases/quoting_test.rb
+++ b/activerecord/test/cases/quoting_test.rb
@@ -154,15 +154,16 @@ module ActiveRecord
       end
 
       def test_crazy_object
-        crazy = Class.new { def to_yaml; 'lol' end }.new
-        assert_equal "'lol'", @quoter.quote(crazy, nil)
-        assert_equal "'lol'", @quoter.quote(crazy, Object.new)
+        crazy = Class.new.new
+        expected = "'#{YAML.dump(crazy)}'"
+        assert_equal expected, @quoter.quote(crazy, nil)
+        assert_equal expected, @quoter.quote(crazy, Object.new)
       end
 
       def test_crazy_object_calls_quote_string
-        crazy = Class.new { def to_yaml; 'lo\l' end }.new
-        assert_equal "'lo\\\\l'", @quoter.quote(crazy, nil)
-        assert_equal "'lo\\\\l'", @quoter.quote(crazy, Object.new)
+        crazy = Class.new { def initialize; @lol = 'lo\l' end }.new
+        assert_match "lo\\\\l", @quoter.quote(crazy, nil)
+        assert_match "lo\\\\l", @quoter.quote(crazy, Object.new)
       end
 
       def test_quote_string_no_column
diff --git a/activerecord/test/cases/relation_scoping_test.rb b/activerecord/test/cases/relation_scoping_test.rb
index 30a783d5a2..5079aec9ba 100644
--- a/activerecord/test/cases/relation_scoping_test.rb
+++ b/activerecord/test/cases/relation_scoping_test.rb
@@ -132,8 +132,6 @@ class RelationScopingTest < ActiveRecord::TestCase
   end
 
   def test_ensure_that_method_scoping_is_correctly_restored
-    scoped_methods = Developer.send(:current_scoped_methods)
-
     begin
       Developer.where("name = 'Jamis'").scoping do
         raise "an exception"
@@ -141,7 +139,7 @@ class RelationScopingTest < ActiveRecord::TestCase
     rescue
     end
 
-    assert_equal scoped_methods, Developer.send(:current_scoped_methods)
+    assert !Developer.scoped.where_values.include?("name = 'Jamis'")
   end
 end
 
@@ -310,72 +308,178 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
   end
 
-  def test_default_scope_with_lambda
-    expected = Post.find_all_by_author_id(2)
-    PostForAuthor.selected_author = 2
-    received = PostForAuthor.all
-    assert_equal expected, received
-    expected = Post.find_all_by_author_id(1)
-    PostForAuthor.selected_author = 1
-    received = PostForAuthor.all
+  def test_default_scope_is_unscoped_on_find
+    assert_equal 1, DeveloperCalledDavid.count
+    assert_equal 11, DeveloperCalledDavid.unscoped.count
+  end
+
+  def test_default_scope_is_unscoped_on_create
+    assert_nil DeveloperCalledJamis.unscoped.create!.name
+  end
+
+  def test_default_scope_with_conditions_string
+    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.find(:all).map(&:id).sort
+    assert_equal nil, DeveloperCalledDavid.create!.name
+  end
+
+  def test_default_scope_with_conditions_hash
+    assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeveloperCalledJamis.find(:all).map(&:id).sort
+    assert_equal 'Jamis', DeveloperCalledJamis.create!.name
+  end
+
+  def test_default_scoping_with_threads
+    2.times do
+      Thread.new { assert DeveloperOrderedBySalary.scoped.to_sql.include?('salary DESC') }.join
+    end
+  end
+
+  def test_default_scope_with_inheritance
+    wheres = InheritedPoorDeveloperCalledJamis.scoped.where_values_hash
+    assert_equal "Jamis", wheres[:name]
+    assert_equal 50000,   wheres[:salary]
+  end
+
+  def test_method_scope
+    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.all_ordered_by_name.collect { |dev| dev.salary }
     assert_equal expected, received
   end
 
-  def test_default_scope_with_thing_that_responds_to_call
-    klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'posts'
+  def test_nested_scope
+    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.send(:with_scope, :find => { :order => 'name DESC'}) do
+      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
     end
+    assert_equal expected, received
+  end
 
-    klass.class_eval do
-      default_scope Class.new(Struct.new(:klass)) {
-        def call
-          klass.where(:author_id => 2)
-        end
-      }.new(self)
+  def test_scope_overwrites_default
+    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.name }
+    received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
+    assert_equal expected, received
+  end
+
+  def test_reorder_overrides_default_scope_order
+    expected = Developer.order('name DESC').collect { |dev| dev.name }
+    received = DeveloperOrderedBySalary.reorder('name DESC').collect { |dev| dev.name }
+    assert_equal expected, received
+  end
+
+  def test_nested_exclusive_scope
+    expected = Developer.find(:all, :limit => 100).collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.send(:with_exclusive_scope, :find => { :limit => 100 }) do
+      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
     end
+    assert_equal expected, received
+  end
+
+  def test_order_in_default_scope_should_prevail
+    expected = Developer.find(:all, :order => 'salary desc').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.find(:all, :order => 'salary').collect { |dev| dev.salary }
+    assert_equal expected, received
+  end
+
+  def test_create_attribute_overwrites_default_scoping
+    assert_equal 'David', PoorDeveloperCalledJamis.create!(:name => 'David').name
+    assert_equal 200000, PoorDeveloperCalledJamis.create!(:name => 'David', :salary => 200000).salary
+  end
+
+  def test_create_attribute_overwrites_default_values
+    assert_equal nil, PoorDeveloperCalledJamis.create!(:salary => nil).salary
+    assert_equal 50000, PoorDeveloperCalledJamis.create!(:name => 'David').salary
+  end
+
+  def test_default_scope_attribute
+    jamis = PoorDeveloperCalledJamis.new(:name => 'David')
+    assert_equal 50000, jamis.salary
+  end
 
-    records = klass.all
-    assert_equal 3, records.length
-    assert_equal 2, records.first.author_id
+  def test_where_attribute
+    aaron = PoorDeveloperCalledJamis.where(:salary => 20).new(:name => 'Aaron')
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+  end
+
+  def test_where_attribute_merge
+    aaron = PoorDeveloperCalledJamis.where(:name => 'foo').new(:name => 'Aaron')
+    assert_equal 'Aaron', aaron.name
+  end
+
+  def test_scope_composed_by_limit_and_then_offset_is_equal_to_scope_composed_by_offset_and_then_limit
+    posts_limit_offset = Post.limit(3).offset(2)
+    posts_offset_limit = Post.offset(2).limit(3)
+    assert_equal posts_limit_offset, posts_offset_limit
+  end
+
+  def test_create_with_merge
+    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).merge(
+              PoorDeveloperCalledJamis.create_with(:name => 'Aaron')).new
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+
+    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).
+                                     create_with(:name => 'Aaron').new
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+  end
+
+  def test_create_with_reset
+    jamis = PoorDeveloperCalledJamis.create_with(:name => 'Aaron').create_with(nil).new
+    assert_equal 'Jamis', jamis.name
+  end
+
+  def test_unscoped_with_named_scope_should_not_have_default_scope
+    assert_equal [DeveloperCalledJamis.find(developers(:poor_jamis).id)], DeveloperCalledJamis.poor
+
+    assert DeveloperCalledJamis.unscoped.poor.include?(developers(:david).becomes(DeveloperCalledJamis))
+    assert_equal 10, DeveloperCalledJamis.unscoped.poor.length
+  end
+end
+
+class DeprecatedDefaultScopingTest < ActiveRecord::TestCase
+  fixtures :developers, :posts
+
+  def test_default_scope
+    expected = Developer.find(:all, :order => 'salary DESC').collect { |dev| dev.salary }
+    received = DeprecatedDeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
+    assert_equal expected, received
   end
 
   def test_default_scope_is_unscoped_on_find
-    assert_equal 1, DeveloperCalledDavid.count
-    assert_equal 11, DeveloperCalledDavid.unscoped.count
+    assert_equal 1, DeprecatedDeveloperCalledDavid.count
+    assert_equal 11, DeprecatedDeveloperCalledDavid.unscoped.count
   end
 
   def test_default_scope_is_unscoped_on_create
-    assert_nil DeveloperCalledJamis.unscoped.create!.name
+    assert_nil DeprecatedDeveloperCalledJamis.unscoped.create!.name
   end
 
   def test_default_scope_with_conditions_string
-    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.find(:all).map(&:id).sort
-    assert_equal nil, DeveloperCalledDavid.create!.name
+    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeprecatedDeveloperCalledDavid.find(:all).map(&:id).sort
+    assert_equal nil, DeprecatedDeveloperCalledDavid.create!.name
   end
 
   def test_default_scope_with_conditions_hash
-    assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeveloperCalledJamis.find(:all).map(&:id).sort
-    assert_equal 'Jamis', DeveloperCalledJamis.create!.name
+    assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeprecatedDeveloperCalledJamis.find(:all).map(&:id).sort
+    assert_equal 'Jamis', DeprecatedDeveloperCalledJamis.create!.name
   end
 
   def test_default_scoping_with_threads
     2.times do
-      Thread.new { assert_equal ['salary DESC'], DeveloperOrderedBySalary.scoped.order_values }.join
+      Thread.new { assert DeprecatedDeveloperOrderedBySalary.scoped.to_sql.include?('salary DESC') }.join
     end
   end
 
   def test_default_scoping_with_inheritance
     # Inherit a class having a default scope and define a new default scope
-    klass = Class.new(DeveloperOrderedBySalary)
-    klass.send :default_scope, :limit => 1
+    klass = Class.new(DeprecatedDeveloperOrderedBySalary)
+    ActiveSupport::Deprecation.silence { klass.send :default_scope, :limit => 1 }
 
     # Scopes added on children should append to parent scope
-    assert_equal 1,               klass.scoped.limit_value
-    assert_equal ['salary DESC'], klass.scoped.order_values
+    assert_equal [developers(:jamis).id], klass.all.map(&:id)
 
     # Parent should still have the original scope
-    assert_nil DeveloperOrderedBySalary.scoped.limit_value
-    assert_equal ['salary DESC'], DeveloperOrderedBySalary.scoped.order_values
+    assert_equal Developer.order('salary DESC').map(&:id), DeprecatedDeveloperOrderedBySalary.all.map(&:id)
   end
 
   def test_default_scope_called_twice_merges_conditions
@@ -385,8 +489,10 @@ class DefaultScopingTest < ActiveRecord::TestCase
     Developer.create!(:name => "Brian", :salary => 100000)
 
     klass = Class.new(Developer)
-    klass.__send__ :default_scope, :conditions => { :name => "David" }
-    klass.__send__ :default_scope, :conditions => { :salary => 100000 }
+    ActiveSupport::Deprecation.silence do
+      klass.__send__ :default_scope, :conditions => { :name => "David" }
+      klass.__send__ :default_scope, :conditions => { :salary => 100000 }
+    end
     assert_equal 1,       klass.count
     assert_equal "David", klass.first.name
     assert_equal 100000,  klass.first.salary
@@ -399,9 +505,11 @@ class DefaultScopingTest < ActiveRecord::TestCase
     Developer.create!(:name => "Brian", :salary => 100000)
 
     klass = Class.new(Developer)
-    klass.class_eval do
-      default_scope where("name = 'David'")
-      default_scope where("salary = 100000")
+    ActiveSupport::Deprecation.silence do
+      klass.class_eval do
+        default_scope where("name = 'David'")
+        default_scope where("salary = 100000")
+      end
     end
 
     assert_equal 1,       klass.count
@@ -411,96 +519,90 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_method_scope
     expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.all_ordered_by_name.collect { |dev| dev.salary }
+    received = DeprecatedDeveloperOrderedBySalary.all_ordered_by_name.collect { |dev| dev.salary }
     assert_equal expected, received
   end
 
   def test_nested_scope
     expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.send(:with_scope, :find => { :order => 'name DESC'}) do
-      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
+    received = DeprecatedDeveloperOrderedBySalary.send(:with_scope, :find => { :order => 'name DESC'}) do
+      DeprecatedDeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
     end
     assert_equal expected, received
   end
 
   def test_scope_overwrites_default
     expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.name }
-    received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
+    received = DeprecatedDeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
     assert_equal expected, received
   end
 
   def test_reorder_overrides_default_scope_order
     expected = Developer.order('name DESC').collect { |dev| dev.name }
-    received = DeveloperOrderedBySalary.reorder('name DESC').collect { |dev| dev.name }
+    received = DeprecatedDeveloperOrderedBySalary.reorder('name DESC').collect { |dev| dev.name }
     assert_equal expected, received
   end
 
   def test_nested_exclusive_scope
     expected = Developer.find(:all, :limit => 100).collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.send(:with_exclusive_scope, :find => { :limit => 100 }) do
-      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
+    received = DeprecatedDeveloperOrderedBySalary.send(:with_exclusive_scope, :find => { :limit => 100 }) do
+      DeprecatedDeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
     end
     assert_equal expected, received
   end
 
   def test_order_in_default_scope_should_prevail
     expected = Developer.find(:all, :order => 'salary desc').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.find(:all, :order => 'salary').collect { |dev| dev.salary }
+    received = DeprecatedDeveloperOrderedBySalary.find(:all, :order => 'salary').collect { |dev| dev.salary }
     assert_equal expected, received
   end
 
   def test_default_scope_using_relation
-    posts = PostWithComment.scoped
-    assert_equal 2, posts.count
+    posts = DeprecatedPostWithComment.scoped
+    assert_equal 2, posts.to_a.length
     assert_equal posts(:thinking), posts.first
   end
 
   def test_create_attribute_overwrites_default_scoping
-    assert_equal 'David', PoorDeveloperCalledJamis.create!(:name => 'David').name
-    assert_equal 200000, PoorDeveloperCalledJamis.create!(:name => 'David', :salary => 200000).salary
+    assert_equal 'David', DeprecatedPoorDeveloperCalledJamis.create!(:name => 'David').name
+    assert_equal 200000, DeprecatedPoorDeveloperCalledJamis.create!(:name => 'David', :salary => 200000).salary
   end
 
   def test_create_attribute_overwrites_default_values
-    assert_equal nil, PoorDeveloperCalledJamis.create!(:salary => nil).salary
-    assert_equal 50000, PoorDeveloperCalledJamis.create!(:name => 'David').salary
+    assert_equal nil, DeprecatedPoorDeveloperCalledJamis.create!(:salary => nil).salary
+    assert_equal 50000, DeprecatedPoorDeveloperCalledJamis.create!(:name => 'David').salary
   end
 
   def test_default_scope_attribute
-    jamis = PoorDeveloperCalledJamis.new(:name => 'David')
+    jamis = DeprecatedPoorDeveloperCalledJamis.new(:name => 'David')
     assert_equal 50000, jamis.salary
   end
 
   def test_where_attribute
-    aaron = PoorDeveloperCalledJamis.where(:salary => 20).new(:name => 'Aaron')
+    aaron = DeprecatedPoorDeveloperCalledJamis.where(:salary => 20).new(:name => 'Aaron')
     assert_equal 20, aaron.salary
     assert_equal 'Aaron', aaron.name
   end
 
   def test_where_attribute_merge
-    aaron = PoorDeveloperCalledJamis.where(:name => 'foo').new(:name => 'Aaron')
+    aaron = DeprecatedPoorDeveloperCalledJamis.where(:name => 'foo').new(:name => 'Aaron')
     assert_equal 'Aaron', aaron.name
   end
 
-  def test_scope_composed_by_limit_and_then_offset_is_equal_to_scope_composed_by_offset_and_then_limit
-    posts_limit_offset = Post.limit(3).offset(2)
-    posts_offset_limit = Post.offset(2).limit(3)
-    assert_equal posts_limit_offset, posts_offset_limit
-  end
-
   def test_create_with_merge
-    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).merge(
-              PoorDeveloperCalledJamis.create_with(:name => 'Aaron')).new
+    aaron = DeprecatedPoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).merge(
+              DeprecatedPoorDeveloperCalledJamis.create_with(:name => 'Aaron')).new
     assert_equal 20, aaron.salary
     assert_equal 'Aaron', aaron.name
 
-    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).
+    aaron = DeprecatedPoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).
                                      create_with(:name => 'Aaron').new
     assert_equal 20, aaron.salary
     assert_equal 'Aaron', aaron.name
   end
 
   def test_create_with_reset
-    jamis = PoorDeveloperCalledJamis.create_with(:name => 'Aaron').create_with(nil).new
+    jamis = DeprecatedPoorDeveloperCalledJamis.create_with(:name => 'Aaron').create_with(nil).new
     assert_equal 'Jamis', jamis.name
   end
 end
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 7bdbd773b6..6874bd18f8 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -20,7 +20,7 @@ module ActiveRecord
     end
 
     def test_single_values
-      assert_equal [:limit, :offset, :lock, :readonly, :create_with, :from].map(&:to_s).sort,
+      assert_equal [:limit, :offset, :lock, :readonly, :create_with, :from, :reorder].map(&:to_s).sort,
         Relation::SINGLE_VALUE_METHODS.map(&:to_s).sort
     end