Merge branch 'master' into adequaterecord

* master: (122 commits)
  Rails.application should be set inside before_configuration hook
  remove check for present? from delete_all
  Remove useless begin..end
  Build the reverse_order on its proper method.
  Use connection-specific bytea escaping
  Ignore order when doing count.
  make enums distinct per class
  Remove unused `subclass_controller_with_flash_type_bar` var from flash test.
  fix CollectionProxy delete_all documentation
  Added OS X specific commands to installation guide [ci skip] Recommended using homebrew for installing MySQL and PostgreSQL
  Fix setup of adding _flash_types test.
  Use SVG version of travis build status badge [skip ci]
  W3C CSP document moved to gihub.io URL [ci skip]
  sprockets-rails was released
  Fix the test defining the models in the right place
  Add CHANGELOG entry for #11650 [ci skip]
  Declare the assets dependency
  Use sass-rails 4.0.3
  Make possible to use sprockets-rails 2.1
  add missing parentheses to validates_with documentation [skip ci]
  ...

15 files changed, 306 insertions, 118 deletions

diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index f5f1c791e1..18dd4a6de8 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -25,8 +25,11 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
 
   def test_column
     assert_equal :string, @column.type
+    assert_equal "character varying", @column.sql_type
     assert @column.array
     assert_not @column.text?
+    assert_not @column.number?
+    assert_not @column.binary?
 
     ratings_column = PgArray.columns_hash['ratings']
     assert_equal :integer, ratings_column.type
@@ -34,6 +37,28 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
     assert_not ratings_column.number?
   end
 
+  def test_default
+    @connection.add_column 'pg_arrays', 'score', :integer, array: true, default: [4, 4, 2]
+    PgArray.reset_column_information
+    column = PgArray.columns_hash["score"]
+
+    assert_equal([4, 4, 2], column.default)
+    assert_equal([4, 4, 2], PgArray.new.score)
+  ensure
+    PgArray.reset_column_information
+  end
+
+  def test_default_strings
+    @connection.add_column 'pg_arrays', 'names', :string, array: true, default: ["foo", "bar"]
+    PgArray.reset_column_information
+    column = PgArray.columns_hash["names"]
+
+    assert_equal(["foo", "bar"], column.default)
+    assert_equal(["foo", "bar"], PgArray.new.names)
+  ensure
+    PgArray.reset_column_information
+  end
+
   def test_change_column_with_array
     @connection.add_column :pg_arrays, :snippets, :string, array: true, default: []
     @connection.change_column :pg_arrays, :snippets, :text, array: true, default: "{}"
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index c3394d7712..84fa199f17 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -70,6 +70,23 @@ class PostgresqlByteaTest < ActiveRecord::TestCase
     assert_equal(data, record.payload)
   end
 
+  def test_via_to_sql
+    data = "'\u001F\\"
+    record = ByteaDataType.create(payload: data)
+    sql = ByteaDataType.where(payload: data).select(:payload).to_sql
+    result = @connection.query(sql)
+    assert_equal([[data]], result)
+  end
+
+  def test_via_to_sql_with_complicating_connection
+    Thread.new do
+      other_conn = ActiveRecord::Base.connection
+      other_conn.execute('SET standard_conforming_strings = off')
+    end.join
+
+    test_via_to_sql
+  end
+
   def test_write_binary
     data = File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'assets', 'example.log'))
     assert(data.size > 1)
diff --git a/activerecord/test/cases/adapters/postgresql/citext_test.rb b/activerecord/test/cases/adapters/postgresql/citext_test.rb
index 148dc9d07c..948bf49a54 100644
--- a/activerecord/test/cases/adapters/postgresql/citext_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/citext_test.rb
@@ -4,74 +4,77 @@ require 'cases/helper'
 require 'active_record/base'
 require 'active_record/connection_adapters/postgresql_adapter'
 
-class PostgresqlCitextTest < ActiveRecord::TestCase
-  class Citext < ActiveRecord::Base
-    self.table_name = 'citexts'
-  end
+if ActiveRecord::Base.connection.supports_extensions?
+  class PostgresqlCitextTest < ActiveRecord::TestCase
+    class Citext < ActiveRecord::Base
+      self.table_name = 'citexts'
+    end
 
-  def setup
-    @connection = ActiveRecord::Base.connection
+    def setup
+      @connection = ActiveRecord::Base.connection
 
-    unless @connection.extension_enabled?('citext')
-      @connection.enable_extension 'citext'
-      @connection.commit_db_transaction
-    end
+      unless @connection.extension_enabled?('citext')
+        @connection.enable_extension 'citext'
+        @connection.commit_db_transaction
+      end
 
-    @connection.reconnect!
+      @connection.reconnect!
 
-    @connection.create_table('citexts') do |t|
-      t.citext 'cival'
+      @connection.create_table('citexts') do |t|
+        t.citext 'cival'
+      end
     end
-    @column = Citext.columns_hash['cival']
-  end
 
-  teardown do
-    @connection.execute 'DROP TABLE IF EXISTS citexts;'
-    @connection.execute 'DROP EXTENSION IF EXISTS citext CASCADE;'
-  end
+    teardown do
+      @connection.execute 'DROP TABLE IF EXISTS citexts;'
+      @connection.execute 'DROP EXTENSION IF EXISTS citext CASCADE;'
+    end
 
-  def test_citext_enabled
-    assert @connection.extension_enabled?('citext')
-  end
+    def test_citext_enabled
+      assert @connection.extension_enabled?('citext')
+    end
 
-  def test_column_type
-    assert_equal :citext, @column.type
-  end
+    def test_column
+      column = Citext.columns_hash['cival']
+      assert_equal :citext, column.type
+      assert_equal 'citext', column.sql_type
+      assert_not column.text?
+      assert_not column.number?
+      assert_not column.binary?
+      assert_not column.array
+    end
 
-  def test_column_sql_type
-    assert_equal 'citext', @column.sql_type
-  end
+    def test_change_table_supports_json
+      @connection.transaction do
+        @connection.change_table('citexts') do |t|
+          t.citext 'username'
+        end
+        Citext.reset_column_information
+        column = Citext.columns.find { |c| c.name == 'username' }
+        assert_equal :citext, column.type
 
-  def test_change_table_supports_json
-    @connection.transaction do
-      @connection.change_table('citexts') do |t|
-        t.citext 'username'
+        raise ActiveRecord::Rollback # reset the schema change
       end
+    ensure
       Citext.reset_column_information
-      column = Citext.columns.find { |c| c.name == 'username' }
-      assert_equal :citext, column.type
-
-      raise ActiveRecord::Rollback # reset the schema change
     end
-  ensure
-    Citext.reset_column_information
-  end
 
-  def test_write
-    x = Citext.new(cival: 'Some CI Text')
-    x.save!
-    citext = Citext.first
-    assert_equal "Some CI Text", citext.cival
+    def test_write
+      x = Citext.new(cival: 'Some CI Text')
+      x.save!
+      citext = Citext.first
+      assert_equal "Some CI Text", citext.cival
 
-    citext.cival = "Some NEW CI Text"
-    citext.save!
+      citext.cival = "Some NEW CI Text"
+      citext.save!
 
-    assert_equal "Some NEW CI Text", citext.reload.cival
-  end
+      assert_equal "Some NEW CI Text", citext.reload.cival
+    end
 
-  def test_select_case_insensitive
-    @connection.execute "insert into citexts (cival) values('Cased Text')"
-    x = Citext.where(cival: 'cased text').first
-    assert_equal 'Cased Text', x.cival
+    def test_select_case_insensitive
+      @connection.execute "insert into citexts (cival) values('Cased Text')"
+      x = Citext.where(cival: 'cased text').first
+      assert_equal 'Cased Text', x.cival
+    end
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/composite_test.rb b/activerecord/test/cases/adapters/postgresql/composite_test.rb
index ed39204145..224b1b770b 100644
--- a/activerecord/test/cases/adapters/postgresql/composite_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/composite_test.rb
@@ -29,6 +29,17 @@ class PostgresqlCompositeTest < ActiveRecord::TestCase
     end
   end
 
+  def test_column
+    column = PostgresqlComposite.columns_hash["address"]
+    # TODO: Composite columns should have a type
+    assert_nil column.type
+    assert_equal "full_address", column.sql_type
+    assert_not column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
+  end
+
   def test_composite_mapping
     @connection.execute "INSERT INTO postgresql_composites VALUES (1, ROW('Paris', 'Champs-Élysées'));"
     composite = PostgresqlComposite.first
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index aa4996133f..5f84c893c0 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -1,19 +1,22 @@
 require "cases/helper"
+require 'support/connection_helper'
 
 module ActiveRecord
   class PostgresqlConnectionTest < ActiveRecord::TestCase
+    include ConnectionHelper
+
     class NonExistentTable < ActiveRecord::Base
     end
 
     def setup
       super
       @subscriber = SQLSubscriber.new
-      ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
+      @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
       @connection = ActiveRecord::Base.connection
     end
 
     def teardown
-      ActiveSupport::Notifications.unsubscribe(@subscriber)
+      ActiveSupport::Notifications.unsubscribe(@subscription)
       super
     end
 
@@ -198,17 +201,5 @@ module ActiveRecord
         ActiveRecord::Base.establish_connection(orig_connection.deep_merge({:variables => {:debug_print_plan => :default}}))
       end
     end
-
-    private
-
-    def run_without_connection
-      original_connection = ActiveRecord::Base.remove_connection
-      begin
-        yield original_connection
-      ensure
-        ActiveRecord::Base.establish_connection(original_connection)
-      end
-    end
-
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/domain_test.rb b/activerecord/test/cases/adapters/postgresql/domain_test.rb
new file mode 100644
index 0000000000..214e89dd7f
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/domain_test.rb
@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+require "cases/helper"
+require 'support/connection_helper'
+require 'active_record/base'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+class PostgresqlDomainTest < ActiveRecord::TestCase
+  include ConnectionHelper
+
+  class PostgresqlDomain < ActiveRecord::Base
+    self.table_name = "postgresql_domains"
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.transaction do
+      @connection.execute "CREATE DOMAIN custom_money as numeric(8,2)"
+      @connection.create_table('postgresql_domains') do |t|
+        t.column :price, :custom_money
+      end
+    end
+
+    # reload type map after creating the enum type
+    @connection.send(:reload_type_map)
+  end
+
+  teardown do
+    @connection.execute 'DROP TABLE IF EXISTS postgresql_domains'
+    @connection.execute 'DROP DOMAIN IF EXISTS custom_money'
+    reset_connection
+  end
+
+  def test_column
+    column = PostgresqlDomain.columns_hash["price"]
+    assert_equal :decimal, column.type
+    assert_equal "custom_money", column.sql_type
+    assert column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
+  end
+
+  def test_domain_acts_like_basetype
+    PostgresqlDomain.create price: ""
+    record = PostgresqlDomain.first
+    assert_nil record.price
+
+    record.price = "34.15"
+    record.save!
+
+    assert_equal BigDecimal.new("34.15"), record.reload.price
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/enum_test.rb b/activerecord/test/cases/adapters/postgresql/enum_test.rb
index 7208edef5f..73da5a74ab 100644
--- a/activerecord/test/cases/adapters/postgresql/enum_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/enum_test.rb
@@ -1,18 +1,16 @@
 # -*- coding: utf-8 -*-
 require "cases/helper"
+require 'support/connection_helper'
 require 'active_record/base'
 require 'active_record/connection_adapters/postgresql_adapter'
 
 class PostgresqlEnumTest < ActiveRecord::TestCase
+  include ConnectionHelper
+
   class PostgresqlEnum < ActiveRecord::Base
     self.table_name = "postgresql_enums"
   end
 
-  teardown do
-    @connection.execute 'DROP TABLE IF EXISTS postgresql_enums'
-    @connection.execute 'DROP TYPE IF EXISTS mood'
-  end
-
   def setup
     @connection = ActiveRecord::Base.connection
     @connection.transaction do
@@ -27,6 +25,22 @@ class PostgresqlEnumTest < ActiveRecord::TestCase
     @connection.send(:reload_type_map)
   end
 
+  teardown do
+    @connection.execute 'DROP TABLE IF EXISTS postgresql_enums'
+    @connection.execute 'DROP TYPE IF EXISTS mood'
+    reset_connection
+  end
+
+  def test_column
+    column = PostgresqlEnum.columns_hash["current_mood"]
+    assert_equal :enum, column.type
+    assert_equal "mood", column.sql_type
+    assert_not column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
+  end
+
   def test_enum_mapping
     @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
     enum = PostgresqlEnum.first
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 90ec1524b5..c24c4b0d56 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -54,6 +54,22 @@ class PostgresqlHstoreTest < ActiveRecord::TestCase
 
     def test_column
       assert_equal :hstore, @column.type
+      assert_equal "hstore", @column.sql_type
+      assert_not @column.number?
+      assert_not @column.text?
+      assert_not @column.binary?
+      assert_not @column.array
+    end
+
+    def test_default
+      @connection.add_column 'hstores', 'permissions', :hstore, default: '"users"=>"read", "articles"=>"write"'
+      Hstore.reset_column_information
+      column = Hstore.columns_hash["permissions"]
+
+      assert_equal({"users"=>"read", "articles"=>"write"}, column.default)
+      assert_equal({"users"=>"read", "articles"=>"write"}, Hstore.new.permissions)
+    ensure
+      Hstore.reset_column_information
     end
 
     def test_change_table_supports_hstore
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index 10c0a6c395..ee793ffff2 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -31,7 +31,24 @@ class PostgresqlJSONTest < ActiveRecord::TestCase
   end
 
   def test_column
-    assert_equal :json, @column.type
+    column = JsonDataType.columns_hash["payload"]
+    assert_equal :json, column.type
+    assert_equal "json", column.sql_type
+    assert_not column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
+  end
+
+  def test_default
+    @connection.add_column 'json_data_type', 'permissions', :json, default: '{"users": "read", "posts": ["read", "write"]}'
+    JsonDataType.reset_column_information
+    column = JsonDataType.columns_hash["permissions"]
+
+    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, column.default)
+    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.new.permissions)
+  ensure
+    JsonDataType.reset_column_information
   end
 
   def test_change_table_supports_json
@@ -57,16 +74,16 @@ class PostgresqlJSONTest < ActiveRecord::TestCase
   end
 
   def test_type_cast_json
-    assert @column
+    column = JsonDataType.columns_hash["payload"]
 
     data = "{\"a_key\":\"a_value\"}"
-    hash = @column.class.string_to_json data
+    hash = column.class.string_to_json data
     assert_equal({'a_key' => 'a_value'}, hash)
-    assert_equal({'a_key' => 'a_value'}, @column.type_cast(data))
+    assert_equal({'a_key' => 'a_value'}, column.type_cast(data))
 
-    assert_equal({}, @column.type_cast("{}"))
-    assert_equal({'key'=>nil}, @column.type_cast('{"key": null}'))
-    assert_equal({'c'=>'}','"a"'=>'b "a b'}, @column.type_cast(%q({"c":"}", "\"a\"":"b \"a b"})))
+    assert_equal({}, column.type_cast("{}"))
+    assert_equal({'key'=>nil}, column.type_cast('{"key": null}'))
+    assert_equal({'c'=>'}','"a"'=>'b "a b'}, column.type_cast(%q({"c":"}", "\"a\"":"b \"a b"})))
   end
 
   def test_rewrite
diff --git a/activerecord/test/cases/adapters/postgresql/ltree_test.rb b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
index e72fd4360d..718f37a380 100644
--- a/activerecord/test/cases/adapters/postgresql/ltree_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/ltree_test.rb
@@ -10,6 +10,11 @@ class PostgresqlLtreeTest < ActiveRecord::TestCase
 
   def setup
     @connection = ActiveRecord::Base.connection
+
+    unless @connection.extension_enabled?('ltree')
+      @connection.enable_extension 'ltree'
+    end
+
     @connection.transaction do
       @connection.create_table('ltrees') do |t|
         t.ltree 'path'
@@ -26,6 +31,11 @@ class PostgresqlLtreeTest < ActiveRecord::TestCase
   def test_column
     column = Ltree.columns_hash['path']
     assert_equal :ltree, column.type
+    assert_equal "ltree", column.sql_type
+    assert_not column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
   end
 
   def test_write
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
index 1122f8b9a1..51846e22d9 100644
--- a/activerecord/test/cases/adapters/postgresql/quoting_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -10,46 +10,46 @@ module ActiveRecord
         end
 
         def test_type_cast_true
-          c = Column.new(nil, 1, 'boolean')
+          c = PostgreSQLColumn.new(nil, 1, OID::Boolean.new, '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')
+          c = PostgreSQLColumn.new(nil, 1, OID::Boolean.new, 'boolean')
           assert_equal 'f', @conn.type_cast(false, nil)
           assert_equal 'f', @conn.type_cast(false, c)
         end
 
         def test_type_cast_cidr
           ip = IPAddr.new('255.0.0.0/8')
-          c = Column.new(nil, ip, 'cidr')
+          c = PostgreSQLColumn.new(nil, ip, OID::Cidr.new, 'cidr')
           assert_equal ip, @conn.type_cast(ip, c)
         end
 
         def test_type_cast_inet
           ip = IPAddr.new('255.1.0.0/8')
-          c = Column.new(nil, ip, 'inet')
+          c = PostgreSQLColumn.new(nil, ip, OID::Cidr.new, 'inet')
           assert_equal ip, @conn.type_cast(ip, c)
         end
 
         def test_quote_float_nan
           nan = 0.0/0
-          c = Column.new(nil, 1, 'float')
+          c = PostgreSQLColumn.new(nil, 1, OID::Float.new, 'float')
           assert_equal "'NaN'", @conn.quote(nan, c)
         end
 
         def test_quote_float_infinity
           infinity = 1.0/0
-          c = Column.new(nil, 1, 'float')
+          c = PostgreSQLColumn.new(nil, 1, OID::Float.new, 'float')
           assert_equal "'Infinity'", @conn.quote(infinity, c)
         end
 
         def test_quote_cast_numeric
           fixnum = 666
-          c = Column.new(nil, nil, 'varchar')
+          c = PostgreSQLColumn.new(nil, nil, OID::String.new, 'varchar')
           assert_equal "'666'", @conn.quote(fixnum, c)
-          c = Column.new(nil, nil, 'text')
+          c = PostgreSQLColumn.new(nil, nil, OID::Text.new, 'text')
           assert_equal "'666'", @conn.quote(fixnum, c)
         end
 
diff --git a/activerecord/test/cases/adapters/postgresql/range_test.rb b/activerecord/test/cases/adapters/postgresql/range_test.rb
index a9d4312fb3..57c7da2657 100644
--- a/activerecord/test/cases/adapters/postgresql/range_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/range_test.rb
@@ -1,4 +1,5 @@
 require "cases/helper"
+require 'support/connection_helper'
 require 'active_record/base'
 require 'active_record/connection_adapters/postgresql_adapter'
 
@@ -8,17 +9,13 @@ if ActiveRecord::Base.connection.supports_ranges?
   end
 
   class PostgresqlRangeTest < ActiveRecord::TestCase
-    teardown do
-      @connection.execute 'DROP TABLE IF EXISTS postgresql_ranges'
-      @connection.execute 'DROP TYPE IF EXISTS floatrange'
-    end
+    self.use_transactional_fixtures = false
+    include ConnectionHelper
 
     def setup
       @connection = PostgresqlRange.connection
       begin
         @connection.transaction do
-          @connection.execute 'DROP TABLE IF EXISTS postgresql_ranges'
-          @connection.execute 'DROP TYPE IF EXISTS floatrange'
           @connection.execute <<_SQL
             CREATE TYPE floatrange AS RANGE (
                 subtype = float8,
@@ -96,6 +93,12 @@ _SQL
       @empty_range = PostgresqlRange.find(105)
     end
 
+    teardown do
+      @connection.execute 'DROP TABLE IF EXISTS postgresql_ranges'
+      @connection.execute 'DROP TYPE IF EXISTS floatrange'
+      reset_connection
+    end
+
     def test_data_type_of_range_types
       assert_equal :daterange, @first_range.column_for_attribute(:date_range).type
       assert_equal :numrange, @first_range.column_for_attribute(:num_range).type
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index 5e5f653d17..11ec7599a3 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -271,13 +271,13 @@ class SchemaTest < ActiveRecord::TestCase
   end
 
   def test_with_uppercase_index_name
-    ActiveRecord::Base.connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
-    assert_nothing_raised { ActiveRecord::Base.connection.remove_index! "things", "#{SCHEMA_NAME}.things_Index"}
+    @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
+    assert_nothing_raised { @connection.remove_index! "things", "#{SCHEMA_NAME}.things_Index"}
+    @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
 
-    ActiveRecord::Base.connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
-    ActiveRecord::Base.connection.schema_search_path = SCHEMA_NAME
-    assert_nothing_raised { ActiveRecord::Base.connection.remove_index! "things", "things_Index"}
-    ActiveRecord::Base.connection.schema_search_path = "public"
+    with_schema_search_path SCHEMA_NAME do
+      assert_nothing_raised { @connection.remove_index! "things", "things_Index"}
+    end
   end
 
   def test_primary_key_with_schema_specified
@@ -328,18 +328,17 @@ class SchemaTest < ActiveRecord::TestCase
   end
 
   def test_prepared_statements_with_multiple_schemas
+    [SCHEMA_NAME, SCHEMA2_NAME].each do |schema_name|
+      with_schema_search_path schema_name do
+        Thing5.create(:id => 1, :name => "thing inside #{SCHEMA_NAME}", :email => "thing1@localhost", :moment => Time.now)
+      end
+    end
 
-    @connection.schema_search_path = SCHEMA_NAME
-    Thing5.create(:id => 1, :name => "thing inside #{SCHEMA_NAME}", :email => "thing1@localhost", :moment => Time.now)
-
-    @connection.schema_search_path = SCHEMA2_NAME
-    Thing5.create(:id => 1, :name => "thing inside #{SCHEMA2_NAME}", :email => "thing1@localhost", :moment => Time.now)
-
-    @connection.schema_search_path = SCHEMA_NAME
-    assert_equal 1, Thing5.count
-
-    @connection.schema_search_path = SCHEMA2_NAME
-    assert_equal 1, Thing5.count
+    [SCHEMA_NAME, SCHEMA2_NAME].each do |schema_name|
+      with_schema_search_path schema_name do
+        assert_equal 1, Thing5.count
+      end
+    end
   end
 
   def test_schema_exists?
diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index f581c4cf39..9e03ea6bee 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -41,7 +41,18 @@ class PostgresqlUUIDTest < ActiveRecord::TestCase
   end
 
   def test_data_type_of_uuid_types
-    assert_equal :uuid, UUIDType.columns_hash["guid"].type
+    column = UUIDType.columns_hash["guid"]
+    assert_equal :uuid, column.type
+    assert_equal "uuid", column.sql_type
+    assert_not column.number?
+    assert_not column.text?
+    assert_not column.binary?
+    assert_not column.array
+  end
+
+  def test_treat_blank_uuid_as_nil
+    UUIDType.create! guid: ''
+    assert_equal(nil, UUIDType.last.guid)
   end
 
   def test_uuid_formats
diff --git a/activerecord/test/cases/adapters/postgresql/view_test.rb b/activerecord/test/cases/adapters/postgresql/view_test.rb
index 08071894c4..47b7d38eda 100644
--- a/activerecord/test/cases/adapters/postgresql/view_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/view_test.rb
@@ -1,11 +1,15 @@
 require "cases/helper"
 
-class ViewTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+module ViewTestConcern
+  extend ActiveSupport::Concern
+
+  included do
+    self.use_transactional_fixtures = false
+    mattr_accessor :view_type
+  end
 
   SCHEMA_NAME = 'test_schema'
   TABLE_NAME = 'things'
-  VIEW_NAME = 'view_things'
   COLUMNS = [
     'id integer',
     'name character varying(50)',
@@ -14,17 +18,19 @@ class ViewTest < ActiveRecord::TestCase
   ]
 
   class ThingView < ActiveRecord::Base
-    self.table_name = 'test_schema.view_things'
   end
 
   def setup
+    super
+    ThingView.table_name = "#{SCHEMA_NAME}.#{view_type}_things"
+
     @connection = ActiveRecord::Base.connection
     @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
-    @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{TABLE_NAME}.table\" (#{COLUMNS.join(',')})"
-    @connection.execute "CREATE VIEW #{SCHEMA_NAME}.#{VIEW_NAME} AS SELECT id,name,email,moment FROM #{SCHEMA_NAME}.#{TABLE_NAME}"
+    @connection.execute "CREATE #{view_type.humanize} #{ThingView.table_name} AS SELECT * FROM #{SCHEMA_NAME}.#{TABLE_NAME}"
   end
 
-  teardown do
+  def teardown
+    super
     @connection.execute "DROP SCHEMA #{SCHEMA_NAME} CASCADE"
   end
 
@@ -35,7 +41,7 @@ class ViewTest < ActiveRecord::TestCase
 
   def test_column_definitions
     assert_nothing_raised do
-      assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{VIEW_NAME}")
+      assert_equal COLUMNS, columns(ThingView.table_name)
     end
   end
 
@@ -47,3 +53,15 @@ class ViewTest < ActiveRecord::TestCase
     end
 
 end
+
+class ViewTest < ActiveRecord::TestCase
+  include ViewTestConcern
+  self.view_type = 'view'
+end
+
+if ActiveRecord::Base.connection.supports_materialized_views?
+  class MaterializedViewTest < ActiveRecord::TestCase
+    include ViewTestConcern
+    self.view_type = 'materialized_view'
+  end
+end