From f96831e5ec200d957265adb7df765214123fbd6e Mon Sep 17 00:00:00 2001
From: Arthur Neves <arthurnn@gmail.com>
Date: Thu, 20 Feb 2014 10:34:57 -0500
Subject: Add regression test for collection proxy reader

[related #14116]
---
 .../test/cases/associations/has_many_through_associations_test.rb  | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index 47592f312e..026a7fe635 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -817,6 +817,13 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert author.named_categories(true).include?(category)
   end
 
+  def test_collection_exists
+    author   = authors(:mary)
+    category = Category.create!(author_ids: [author.id], name: "Primary")
+    assert category.authors.exists?(id: author.id)
+    assert category.reload.authors.exists?(id: author.id)
+  end
+
   def test_collection_delete_with_nonstandard_primary_key_on_belongs_to
     author   = authors(:mary)
     category = author.named_categories.create(:name => "Primary")
-- 
cgit v1.2.3


From 358802b850df595e071abe3b9d392225a0481d6b Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Thu, 20 Feb 2014 10:46:53 -0800
Subject: Revert "context in validation goes through has many relationship"

This reverts commit 5e3d466d52fa4e9a42c3a1f8773a7c31da875e48.
---
 .../test/cases/associations/has_many_associations_test.rb      | 10 ----------
 activerecord/test/models/pirate.rb                             |  8 --------
 activerecord/test/models/ship.rb                               |  8 --------
 3 files changed, 26 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 321440cab7..a86fb15719 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -22,8 +22,6 @@ require 'models/engine'
 require 'models/categorization'
 require 'models/minivan'
 require 'models/speedometer'
-require 'models/pirate'
-require 'models/ship'
 
 class HasManyAssociationsTestForReorderWithJoinDependency < ActiveRecord::TestCase
   fixtures :authors, :posts, :comments
@@ -1832,12 +1830,4 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       end
     end
   end
-
-  test 'has_many_association passes context validation to validate children' do
-    pirate = FamousPirate.new
-    pirate.famous_ships << ship = FamousShip.new
-    assert_equal true, pirate.valid?
-    assert_equal false, pirate.valid?(:conference)
-    assert_equal "can't be blank", ship.errors[:name].first
-  end
 end
diff --git a/activerecord/test/models/pirate.rb b/activerecord/test/models/pirate.rb
index 8510c596a7..7bb0caf44b 100644
--- a/activerecord/test/models/pirate.rb
+++ b/activerecord/test/models/pirate.rb
@@ -85,11 +85,3 @@ end
 class DestructivePirate < Pirate
   has_one :dependent_ship, :class_name => 'Ship', :foreign_key => :pirate_id, :dependent => :destroy
 end
-
-class FamousPirate < ActiveRecord::Base
-  self.table_name = 'pirates'
-
-  has_many :famous_ships
-
-  validates_presence_of :catchphrase, on: :conference
-end
diff --git a/activerecord/test/models/ship.rb b/activerecord/test/models/ship.rb
index 7a369b9d9a..3da031946f 100644
--- a/activerecord/test/models/ship.rb
+++ b/activerecord/test/models/ship.rb
@@ -17,11 +17,3 @@ class Ship < ActiveRecord::Base
     false
   end
 end
-
-class FamousShip < ActiveRecord::Base
-  self.table_name = 'ships'
-
-  belongs_to :famous_pirate
-
-  validates_presence_of :name, on: :conference
-end
-- 
cgit v1.2.3


From 7eaebd85798c8f56baea4a09d7e08b17d5dcc02c Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Thu, 20 Feb 2014 11:25:48 -0800
Subject: adding a test for #14106

---
 .../test/cases/autosave_association_test.rb        | 25 ++++++++++++++++++++++
 1 file changed, 25 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index c55dd685a1..d2f97df0fc 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -21,6 +21,31 @@ require 'models/electron'
 require 'models/molecule'
 
 class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
+  def test_autosave_validation
+    person = Class.new(ActiveRecord::Base) {
+      self.table_name = 'people'
+      validate :should_be_cool, :on => :create
+      def self.name; 'Person'; end
+
+      private
+
+      def should_be_cool
+        unless self.first_name == 'cool'
+          errors.add :first_name, "not cool"
+        end
+      end
+    }
+    reference = Class.new(ActiveRecord::Base) {
+      self.table_name = "references"
+      def self.name; 'Reference'; end
+      belongs_to :person, autosave: true, class: person
+    }
+
+    u = person.create!(first_name: 'cool')
+    u.update_attributes!(first_name: 'nah') # still valid because validation only applies on 'create'
+    assert reference.create!(person: u).persisted?
+  end
+
   def test_should_not_add_the_same_callbacks_multiple_times_for_has_one
     assert_no_difference_when_adding_callbacks_twice_for Pirate, :ship
   end
-- 
cgit v1.2.3


From 283a2edec2f8ccdf90fb58025608f02a63948fa0 Mon Sep 17 00:00:00 2001
From: schneems <richard.schneeman@gmail.com>
Date: Fri, 21 Feb 2014 16:04:21 -0600
Subject: Handle missing environment from non empty config

If using a `DATABASE_URL` and a `database.yml`. The connection information in `DATABASE_URL` should be merged into whatever environment we are in. As released in 4.1.0rc1 if someone has a database.yml but is missing a key like production:

```yml
development:
  host: localhost

```

Then the check for blank config will return false so the information from the `DATABASE_URL` will not be used when attempting to connect to the `production` database and the connection will incorrectly fail.

This commit fixes this problem and adds a test for the behavior.

In addition the ability to specify a connection url in a `database.yml` like this:

```
production: postgres://localhost/foo
```

Was introduced in 4.1.0rc1 though should not be used, instead using a url sub key

```
production:
  url: postgres://localhost/foo
```

This url sub key was also introduced in 4.1.0rc1 though the `production: postgres://localhost/foo` was not removed. As a result we should not test this behavior.
---
 .../connection_adapters/connection_handler_test.rb | 23 ++++++++--------------
 1 file changed, 8 insertions(+), 15 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/connection_adapters/connection_handler_test.rb b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
index 318cc5a32c..599e8c762c 100644
--- a/activerecord/test/cases/connection_adapters/connection_handler_test.rb
+++ b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
@@ -17,6 +17,14 @@ module ActiveRecord
         ENV["DATABASE_URL"] = @previous_database_url
       end
 
+      def test_environment_does_not_exist_in_config_url_does_exist
+        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        config      = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        actual      = klass.new(config).resolve
+        expect_prod = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
+        assert_equal expect_prod, actual["production"]
+      end
+
       def test_string_connection
         config   = { "production" => "postgres://localhost/foo" }
         actual   = klass.new(config).resolve
@@ -69,21 +77,6 @@ module ActiveRecord
         assert_equal nil,      actual[:test]
       end
 
-      def test_sting_with_database_url
-        ENV['DATABASE_URL'] = "NOT-POSTGRES://localhost/NOT_FOO"
-
-        config   = { "production" => "postgres://localhost/foo" }
-        actual   = klass.new(config).resolve
-
-        expected = { "production" =>
-                     { "adapter"  => "postgresql",
-                       "database" => "foo",
-                       "host"     => "localhost"
-                      }
-                    }
-        assert_equal expected, actual
-      end
-
       def test_url_sub_key_with_database_url
         ENV['DATABASE_URL'] = "NOT-POSTGRES://localhost/NOT_FOO"
 
-- 
cgit v1.2.3


From 40a9d8987711f7973c5e95087bcc0c59e167294b Mon Sep 17 00:00:00 2001
From: Jon Leighton <j@jonathanleighton.com>
Date: Sun, 23 Feb 2014 11:14:05 +0000
Subject: Add tests for default scope behaviour change

See #13875
---
 .../test/cases/scoping/default_scoping_test.rb         | 18 ++++++++++++++++++
 activerecord/test/models/developer.rb                  |  2 ++
 2 files changed, 20 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index 170e9a49eb..9a4d8c6740 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -395,4 +395,22 @@ class DefaultScopingTest < ActiveRecord::TestCase
       threads.each(&:join)
     end
   end
+
+  test "additional conditions are ANDed with the default scope" do
+    scope = DeveloperCalledJamis.where(name: "David")
+    assert_equal 2, scope.where_values.length
+    assert_equal [], scope.to_a
+  end
+
+  test "additional conditions in a scope are ANDed with the default scope" do
+    scope = DeveloperCalledJamis.david
+    assert_equal 2, scope.where_values.length
+    assert_equal [], scope.to_a
+  end
+
+  test "a scope can remove the condition from the default scope" do
+    scope = DeveloperCalledJamis.david2
+    assert_equal 1, scope.where_values.length
+    assert_equal Developer.where(name: "David").map(&:id), scope.map(&:id)
+  end
 end
diff --git a/activerecord/test/models/developer.rb b/activerecord/test/models/developer.rb
index 2e2d8a0d37..762259ffa3 100644
--- a/activerecord/test/models/developer.rb
+++ b/activerecord/test/models/developer.rb
@@ -165,6 +165,8 @@ class DeveloperCalledJamis < ActiveRecord::Base
 
   default_scope { where(:name => 'Jamis') }
   scope :poor, -> { where('salary < 150000') }
+  scope :david, -> { where name: "David" }
+  scope :david2, -> { unscoped.where name: "David" }
 end
 
 class PoorDeveloperCalledJamis < ActiveRecord::Base
-- 
cgit v1.2.3


From 4cb47167e747e8f9dc12b0ddaf82bdb68c03e032 Mon Sep 17 00:00:00 2001
From: Yves Senn <yves.senn@gmail.com>
Date: Tue, 21 Jan 2014 12:14:11 +0100
Subject: dynamically define PostgreSQL OID range types.

This gets AR working with custom defined range types. It also
removes the need for subtype specific branches in `OID::Range`.

This expands the interface of all `OID` types with the `infinity` method.
It's responsible to provide a value for positive and negative infinity.
---
 .../test/cases/adapters/postgresql/range_test.rb   | 51 +++++++++++++++++-----
 1 file changed, 40 insertions(+), 11 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/postgresql/range_test.rb b/activerecord/test/cases/adapters/postgresql/range_test.rb
index 5c2d8e1c1d..b621a1468a 100644
--- a/activerecord/test/cases/adapters/postgresql/range_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/range_test.rb
@@ -10,12 +10,22 @@ if ActiveRecord::Base.connection.supports_ranges?
   class PostgresqlRangeTest < ActiveRecord::TestCase
     def teardown
       @connection.execute 'DROP TABLE IF EXISTS postgresql_ranges'
+      @connection.execute 'DROP TYPE IF EXISTS floatrange'
     end
 
     def setup
-      @connection = ActiveRecord::Base.connection
+      @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,
+                subtype_diff = float8mi
+            );
+_SQL
+
           @connection.create_table('postgresql_ranges') do |t|
             t.daterange :date_range
             t.numrange :num_range
@@ -24,7 +34,11 @@ if ActiveRecord::Base.connection.supports_ranges?
             t.int4range :int4_range
             t.int8range :int8_range
           end
+
+          @connection.add_column 'postgresql_ranges', 'float_range', 'floatrange'
         end
+        @connection.send :reload_type_map
+        PostgresqlRange.reset_column_information
       rescue ActiveRecord::StatementInvalid
         skip "do not test on PG without range"
       end
@@ -35,15 +49,17 @@ if ActiveRecord::Base.connection.supports_ranges?
                    ts_range: "[''2010-01-01 14:30'', ''2011-01-01 14:30'']",
                    tstz_range: "[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'']",
                    int4_range: "[1, 10]",
-                   int8_range: "[10, 100]")
+                   int8_range: "[10, 100]",
+                   float_range: "[0.5, 0.7]")
 
       insert_range(id: 102,
                    date_range: "(''2012-01-02'', ''2012-01-04'')",
-                   num_range: "[0.1, 0.2)",
-                   ts_range: "[''2010-01-01 14:30'', ''2011-01-01 14:30'')",
-                   tstz_range: "[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'')",
+                   num_range: "(0.1, 0.2)",
+                   ts_range: "(''2010-01-01 14:30'', ''2011-01-01 14:30'')",
+                   tstz_range: "(''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'')",
                    int4_range: "(1, 10)",
-                   int8_range: "(10, 100)")
+                   int8_range: "(10, 100)",
+                   float_range: "(0.5, 0.7)")
 
       insert_range(id: 103,
                    date_range: "(''2012-01-02'',]",
@@ -51,7 +67,8 @@ if ActiveRecord::Base.connection.supports_ranges?
                    ts_range: "[''2010-01-01 14:30'',]",
                    tstz_range: "[''2010-01-01 14:30:00+05'',]",
                    int4_range: "(1,]",
-                   int8_range: "(10,]")
+                   int8_range: "(10,]",
+                   float_range: "[0.5,]")
 
       insert_range(id: 104,
                    date_range: "[,]",
@@ -59,7 +76,8 @@ if ActiveRecord::Base.connection.supports_ranges?
                    ts_range: "[,]",
                    tstz_range: "[,]",
                    int4_range: "[,]",
-                   int8_range: "[,]")
+                   int8_range: "[,]",
+                   float_range: "[,]")
 
       insert_range(id: 105,
                    date_range: "(''2012-01-02'', ''2012-01-02'')",
@@ -67,7 +85,8 @@ if ActiveRecord::Base.connection.supports_ranges?
                    ts_range: "(''2010-01-01 14:30'', ''2010-01-01 14:30'')",
                    tstz_range: "(''2010-01-01 14:30:00+05'', ''2010-01-01 06:30:00-03'')",
                    int4_range: "(1, 1)",
-                   int8_range: "(10, 10)")
+                   int8_range: "(10, 10)",
+                   float_range: "(0.5, 0.5)")
 
       @new_range = PostgresqlRange.new
       @first_range = PostgresqlRange.find(101)
@@ -133,6 +152,14 @@ if ActiveRecord::Base.connection.supports_ranges?
       assert_nil @empty_range.tstz_range
     end
 
+    def test_custom_range_values
+      assert_equal 0.5..0.7, @first_range.float_range
+      assert_equal 0.5...0.7, @second_range.float_range
+      assert_equal 0.5...Float::INFINITY, @third_range.float_range
+      assert_equal -Float::INFINITY...Float::INFINITY, @fourth_range.float_range
+      assert_nil @empty_range.float_range
+    end
+
     def test_create_tstzrange
       tstzrange = Time.parse('2010-01-01 14:30:00 +0100')...Time.parse('2011-02-02 14:30:00 CDT')
       round_trip(@new_range, :tstz_range, tstzrange)
@@ -229,7 +256,8 @@ if ActiveRecord::Base.connection.supports_ranges?
             ts_range,
             tstz_range,
             int4_range,
-            int8_range
+            int8_range,
+            float_range
           ) VALUES (
             #{values[:id]},
             '#{values[:date_range]}',
@@ -237,7 +265,8 @@ if ActiveRecord::Base.connection.supports_ranges?
             '#{values[:ts_range]}',
             '#{values[:tstz_range]}',
             '#{values[:int4_range]}',
-            '#{values[:int8_range]}'
+            '#{values[:int8_range]}',
+            '#{values[:float_range]}'
           )
         SQL
       end
-- 
cgit v1.2.3


From 91949e48cf41af9f3e4ffba3e5eecf9b0a08bfc3 Mon Sep 17 00:00:00 2001
From: Yves Senn <yves.senn@gmail.com>
Date: Wed, 22 Jan 2014 14:20:01 +0100
Subject: deprecate support for pg ranges with excluding beginnings.

The Ruby Range object does not support excluding beginnings.
We currently support excluding beginnings for some subtypes using
manually by incrementing them (now using the `#succ` method).
This is approach is flawed as it's not equal to an excluding beginning.

This commit deprecates the current support for excluding beginnings.
It also raises an `ArgumentError` for subtypes that do not implement the `succ`
method.

This is a temporary solution to get rid of the broken state. We might still
add complete support for excluding beginnings afterwards. (Probably with a
new `PGRange` object, which acts like a `Range` but has excluding beginnings.
---
 .../test/cases/adapters/postgresql/range_test.rb   | 78 +++++++++++++++-------
 1 file changed, 55 insertions(+), 23 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/postgresql/range_test.rb b/activerecord/test/cases/adapters/postgresql/range_test.rb
index b621a1468a..306bb09a0d 100644
--- a/activerecord/test/cases/adapters/postgresql/range_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/range_test.rb
@@ -53,21 +53,21 @@ _SQL
                    float_range: "[0.5, 0.7]")
 
       insert_range(id: 102,
-                   date_range: "(''2012-01-02'', ''2012-01-04'')",
-                   num_range: "(0.1, 0.2)",
-                   ts_range: "(''2010-01-01 14:30'', ''2011-01-01 14:30'')",
-                   tstz_range: "(''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'')",
-                   int4_range: "(1, 10)",
-                   int8_range: "(10, 100)",
-                   float_range: "(0.5, 0.7)")
+                   date_range: "[''2012-01-02'', ''2012-01-04'')",
+                   num_range: "[0.1, 0.2)",
+                   ts_range: "[''2010-01-01 14:30'', ''2011-01-01 14:30'')",
+                   tstz_range: "[''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'')",
+                   int4_range: "[1, 10)",
+                   int8_range: "[10, 100)",
+                   float_range: "[0.5, 0.7)")
 
       insert_range(id: 103,
-                   date_range: "(''2012-01-02'',]",
+                   date_range: "[''2012-01-02'',]",
                    num_range: "[0.1,]",
                    ts_range: "[''2010-01-01 14:30'',]",
                    tstz_range: "[''2010-01-01 14:30:00+05'',]",
-                   int4_range: "(1,]",
-                   int8_range: "(10,]",
+                   int4_range: "[1,]",
+                   int8_range: "[10,]",
                    float_range: "[0.5,]")
 
       insert_range(id: 104,
@@ -80,13 +80,13 @@ _SQL
                    float_range: "[,]")
 
       insert_range(id: 105,
-                   date_range: "(''2012-01-02'', ''2012-01-02'')",
-                   num_range: "(0.1, 0.1)",
-                   ts_range: "(''2010-01-01 14:30'', ''2010-01-01 14:30'')",
-                   tstz_range: "(''2010-01-01 14:30:00+05'', ''2010-01-01 06:30:00-03'')",
-                   int4_range: "(1, 1)",
-                   int8_range: "(10, 10)",
-                   float_range: "(0.5, 0.5)")
+                   date_range: "[''2012-01-02'', ''2012-01-02'')",
+                   num_range: "[0.1, 0.1)",
+                   ts_range: "[''2010-01-01 14:30'', ''2010-01-01 14:30'')",
+                   tstz_range: "[''2010-01-01 14:30:00+05'', ''2010-01-01 06:30:00-03'')",
+                   int4_range: "[1, 1)",
+                   int8_range: "[10, 10)",
+                   float_range: "[0.5, 0.5)")
 
       @new_range = PostgresqlRange.new
       @first_range = PostgresqlRange.find(101)
@@ -107,24 +107,24 @@ _SQL
 
     def test_int4range_values
       assert_equal 1...11, @first_range.int4_range
-      assert_equal 2...10, @second_range.int4_range
-      assert_equal 2...Float::INFINITY, @third_range.int4_range
+      assert_equal 1...10, @second_range.int4_range
+      assert_equal 1...Float::INFINITY, @third_range.int4_range
       assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.int4_range)
       assert_nil @empty_range.int4_range
     end
 
     def test_int8range_values
       assert_equal 10...101, @first_range.int8_range
-      assert_equal 11...100, @second_range.int8_range
-      assert_equal 11...Float::INFINITY, @third_range.int8_range
+      assert_equal 10...100, @second_range.int8_range
+      assert_equal 10...Float::INFINITY, @third_range.int8_range
       assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.int8_range)
       assert_nil @empty_range.int8_range
     end
 
     def test_daterange_values
       assert_equal Date.new(2012, 1, 2)...Date.new(2012, 1, 5), @first_range.date_range
-      assert_equal Date.new(2012, 1, 3)...Date.new(2012, 1, 4), @second_range.date_range
-      assert_equal Date.new(2012, 1, 3)...Float::INFINITY, @third_range.date_range
+      assert_equal Date.new(2012, 1, 2)...Date.new(2012, 1, 4), @second_range.date_range
+      assert_equal Date.new(2012, 1, 2)...Float::INFINITY, @third_range.date_range
       assert_equal(-Float::INFINITY...Float::INFINITY, @fourth_range.date_range)
       assert_nil @empty_range.date_range
     end
@@ -230,6 +230,38 @@ _SQL
       assert_nil_round_trip(@first_range, :int8_range, 39999...39999)
     end
 
+    def test_exclude_beginning_for_subtypes_with_succ_method_is_deprecated
+      tz = ::ActiveRecord::Base.default_timezone
+
+      silence_warnings {
+        assert_deprecated {
+          range = PostgresqlRange.create!(date_range: "(''2012-01-02'', ''2012-01-04'']")
+          assert_equal Date.new(2012, 1, 3)..Date.new(2012, 1, 4), range.date_range
+        }
+        assert_deprecated {
+          range = PostgresqlRange.create!(ts_range: "(''2010-01-01 14:30'', ''2011-01-01 14:30'']")
+          assert_equal Time.send(tz, 2010, 1, 1, 14, 30, 1)..Time.send(tz, 2011, 1, 1, 14, 30, 0), range.ts_range
+        }
+        assert_deprecated {
+          range = PostgresqlRange.create!(tstz_range: "(''2010-01-01 14:30:00+05'', ''2011-01-01 14:30:00-03'']")
+          assert_equal Time.parse('2010-01-01 09:30:01 UTC')..Time.parse('2011-01-01 17:30:00 UTC'), range.tstz_range
+        }
+        assert_deprecated {
+          range = PostgresqlRange.create!(int4_range: "(1, 10]")
+          assert_equal 2..10, range.int4_range
+        }
+        assert_deprecated {
+          range = PostgresqlRange.create!(int8_range: "(10, 100]")
+          assert_equal 11..100, range.int8_range
+        }
+      }
+    end
+
+    def test_exclude_beginning_for_subtypes_without_succ_method_is_not_supported
+      assert_raises(ArgumentError) { PostgresqlRange.create!(num_range: "(0.1, 0.2]") }
+      assert_raises(ArgumentError) { PostgresqlRange.create!(float_range: "(0.5, 0.7]") }
+    end
+
     private
       def assert_equal_round_trip(range, attribute, value)
         round_trip(range, attribute, value)
-- 
cgit v1.2.3


From d9314b4c0a8b32f242ed4d394dcc3d45ddfb4c62 Mon Sep 17 00:00:00 2001
From: Yves Senn <yves.senn@gmail.com>
Date: Wed, 7 Aug 2013 18:56:49 +0200
Subject: Coerce strings when reading attributes.

---
 activerecord/test/cases/attribute_methods_test.rb | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 6c581a432f..38a43de05a 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -555,6 +555,24 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_converted_values_are_returned_after_assignment
+    developer = Developer.new(name: 1337, salary: "50000")
+
+    assert_equal "50000", developer.salary_before_type_cast
+    assert_equal 1337, developer.name_before_type_cast
+
+    assert_equal 50000, developer.salary
+    assert_equal "1337", developer.name
+
+    developer.save!
+
+    assert_equal "50000", developer.salary_before_type_cast
+    assert_equal 1337, developer.name_before_type_cast
+
+    assert_equal 50000, developer.salary
+    assert_equal "1337", developer.name
+  end
+
   def test_write_nil_to_time_attributes
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new
-- 
cgit v1.2.3


From 41554319f8454f667b5e315339d3e286dbf6e1a4 Mon Sep 17 00:00:00 2001
From: Godfrey Chan <godfreykfc@gmail.com>
Date: Thu, 13 Feb 2014 11:49:19 -0800
Subject: Fixed STI classes not defining an attribute method if there is a
 conflicting private method defined on its ancestors.

The problem is that `method_defined_within?(name, klass, superklass)`
only works correclty when `klass` and `superklass` are both `Class`es.

If both `klass` and `superklass` are both `Class`es, they share the
same inheritance chain, so if a method is defined on `klass` but not
`superklass`, this method must be introduced at some point between
`klass` and `superklass`.

This does not work when `superklass` is a `Module`. A `Module`'s
inheritance chain contains just itself. So if a method is defined on
`klass` but not on `superklass`, the method could still be defined
somewhere upstream, e.g. in `Object`.

This fix works by avoiding calling `method_defined_within?` with a
module while still fufilling the requirement (checking that the
method is defined withing `superclass` but not is not a generated
attribute method).

4d8ee288 is likely an attempted partial fix for this problem. This
unrolls that fix and properly check the `superclass` as intended.

Fixes #11569.
---
 activerecord/test/cases/attribute_methods_test.rb | 30 ++++++++++++++---------
 activerecord/test/fixtures/computers.yml          |  1 +
 activerecord/test/schema/schema.rb                |  1 +
 3 files changed, 21 insertions(+), 11 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 6c581a432f..aec1ea3972 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -728,19 +728,27 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert "unknown attribute: hello", error.message
   end
 
-  def test_read_attribute_overwrites_private_method_not_considered_implemented
-    # simulate a model with a db column that shares its name an inherited
-    # private method (e.g. Object#system)
-    #
-    Object.class_eval do
-      private
-      def title; "private!"; end
+  def test_global_methods_are_overwritten
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'computers'
+    end
+
+    assert !klass.instance_method_already_implemented?(:system)
+    computer = klass.new
+    assert_nil computer.system
+  end
+
+  def test_global_methods_are_overwritte_when_subclassing
+    klass = Class.new(ActiveRecord::Base) { self.abstract_class = true }
+
+    subklass = Class.new(klass) do
+      self.table_name = 'computers'
     end
-    assert !@target.instance_method_already_implemented?(:title)
-    topic = @target.new
-    assert_nil topic.title
 
-    Object.send(:undef_method, :title) # remove test method from object
+    assert !klass.instance_method_already_implemented?(:system)
+    assert !subklass.instance_method_already_implemented?(:system)
+    computer = subklass.new
+    assert_nil computer.system
   end
 
   def test_instance_method_should_be_defined_on_the_base_class
diff --git a/activerecord/test/fixtures/computers.yml b/activerecord/test/fixtures/computers.yml
index daf969d7da..7281a4d768 100644
--- a/activerecord/test/fixtures/computers.yml
+++ b/activerecord/test/fixtures/computers.yml
@@ -1,4 +1,5 @@
 workstation:
   id: 1
+  system: 'Linux'
   developer: 1
   extendedWarranty: 1
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 99a53434f6..5f2d6acbcb 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -198,6 +198,7 @@ ActiveRecord::Schema.define do
   end
 
   create_table :computers, force: true do |t|
+    t.string :system
     t.integer :developer, null: false
     t.integer :extendedWarranty, null: false
   end
-- 
cgit v1.2.3


From d64673c8fe00539a5e5c21c334d92f689e916444 Mon Sep 17 00:00:00 2001
From: Yasuo Honda <yasuo.honda@gmail.com>
Date: Mon, 24 Feb 2014 22:33:43 +0900
Subject: Skip test_migrate_revert_add_index_with_name if databases do not
 allow to create duplicate indexes on the same columns

---
 .../test/cases/invertible_migration_test.rb        | 23 ++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/invertible_migration_test.rb b/activerecord/test/cases/invertible_migration_test.rb
index debacf815c..2b1749cf70 100644
--- a/activerecord/test/cases/invertible_migration_test.rb
+++ b/activerecord/test/cases/invertible_migration_test.rb
@@ -271,16 +271,19 @@ module ActiveRecord
       ActiveRecord::Base.table_name_prefix = ActiveRecord::Base.table_name_suffix = ''
     end
 
-    def test_migrate_revert_add_index_with_name
-      RevertNamedIndexMigration1.new.migrate(:up)
-      RevertNamedIndexMigration2.new.migrate(:up)
-      RevertNamedIndexMigration2.new.migrate(:down)
-
-      connection = ActiveRecord::Base.connection
-      assert connection.index_exists?(:horses, :content),
-             "index on content should exist"
-      assert !connection.index_exists?(:horses, :content, name: "horses_index_named"),
-             "horses_index_named index should not exist"
+    # MySQL 5.7 and Oracle do not allow to create duplicate indexes on the same columns
+    unless current_adapter?(:MysqlAdapter, :Mysql2Adapter, :OracleAdapter)
+      def test_migrate_revert_add_index_with_name
+        RevertNamedIndexMigration1.new.migrate(:up)
+        RevertNamedIndexMigration2.new.migrate(:up)
+        RevertNamedIndexMigration2.new.migrate(:down)
+
+        connection = ActiveRecord::Base.connection
+        assert connection.index_exists?(:horses, :content),
+               "index on content should exist"
+        assert !connection.index_exists?(:horses, :content, name: "horses_index_named"),
+              "horses_index_named index should not exist"
+      end
     end
 
   end
-- 
cgit v1.2.3


From b1656fa6305a5c8237027ab8165d7292751c0e86 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Tue, 25 Feb 2014 14:57:06 -0800
Subject: let `insert_record` actuall save the object.

`before_add` callbacks are fired before the record is saved on
`has_and_belongs_to_many` assocations *and* on `has_many :through`
associations.  Before this change, `before_add` callbacks would be fired
before the record was saved on `has_and_belongs_to_many` associations, but
*not* on `has_many :through` associations.

Fixes #14144
---
 .../test/cases/associations/callbacks_test.rb       | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index 2d0d4541b4..e555c52281 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -101,6 +101,27 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
                   "after_adding#{david.id}"], ar.developers_log
   end
 
+  def test_has_and_belongs_to_many_before_add_called_before_save
+    dev     = nil
+    new_dev = nil
+    klass = Class.new(Project) do
+      def self.name; Project.name; end
+      has_and_belongs_to_many :developers_with_callbacks,
+                                :class_name => "Developer",
+                                :before_add => lambda { |o,r|
+        dev     = r
+        new_dev = r.new_record?
+      }
+    end
+    rec = klass.create!
+    alice = Developer.new(:name => 'alice')
+    rec.developers_with_callbacks << alice
+    assert_equal alice, dev
+    assert_not_nil new_dev
+    assert new_dev, "record should not have been saved"
+    assert_not alice.new_record?
+  end
+
   def test_has_and_belongs_to_many_after_add_called_after_save
     ar = projects(:active_record)
     assert ar.developers_log.empty?
-- 
cgit v1.2.3


From cfb22381451b8984c57f3be2bd39819a0e8ad858 Mon Sep 17 00:00:00 2001
From: Yves Senn <yves.senn@gmail.com>
Date: Tue, 11 Feb 2014 14:41:11 +0100
Subject: test case for custom PostgreSQL enum type.

This test currently outputs the following warning:

```
unknown OID: current_mood(3567879) (SELECT  "postgresql_enums".* FROM "postgresql_enums"   ORDER BY "postgresql_enums"."id" ASC LIMIT 1)
unknown OID: current_mood(3567879) (SELECT  "postgresql_enums".* FROM "postgresql_enums"  WHERE "postgresql_enums"."id" = $1 LIMIT 1)
```

We have an open PR to deal with this issue. It will dynamically
register the OID for enum columns. This test case is merely to exhibit
the current behavior of PostgreSQL enum columns.
---
 .../test/cases/adapters/postgresql/enum_test.rb    | 38 ++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 activerecord/test/cases/adapters/postgresql/enum_test.rb

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/postgresql/enum_test.rb b/activerecord/test/cases/adapters/postgresql/enum_test.rb
new file mode 100644
index 0000000000..bf8dbd6c3f
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/enum_test.rb
@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+require "cases/helper"
+require 'active_record/base'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+class PostgresqlEnumTest < ActiveRecord::TestCase
+  class PostgresqlEnum < ActiveRecord::Base
+    self.table_name = "postgresql_enums"
+  end
+
+  def teardown
+    @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
+      @connection.execute <<-SQL
+        CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
+      SQL
+      @connection.create_table('postgresql_enums') do |t|
+        t.column :current_mood, :mood
+      end
+    end
+  end
+
+  def test_enum_mapping
+    @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
+    enum = PostgresqlEnum.first
+    assert_equal "sad", enum.current_mood
+
+    enum.current_mood = "happy"
+    enum.save!
+
+    assert_equal "happy", enum.reload.current_mood
+  end
+end
-- 
cgit v1.2.3


From 50be1d0d20f6e1a487ad329374d105e931a60ebb Mon Sep 17 00:00:00 2001
From: Yves Senn <yves.senn@gmail.com>
Date: Wed, 26 Feb 2014 15:56:11 +0100
Subject: move PostgreSQL UUID tests from `datatype_test.rb` to `uuid_test.rb`.

---
 .../cases/adapters/postgresql/datatype_test.rb     | 17 +----------
 .../test/cases/adapters/postgresql/uuid_test.rb    | 35 ++++++++++++++++++++++
 2 files changed, 36 insertions(+), 16 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/postgresql/datatype_test.rb b/activerecord/test/cases/adapters/postgresql/datatype_test.rb
index 5c3a797c41..158bc6ee89 100644
--- a/activerecord/test/cases/adapters/postgresql/datatype_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/datatype_test.rb
@@ -27,9 +27,6 @@ end
 class PostgresqlTimestampWithZone < ActiveRecord::Base
 end
 
-class PostgresqlUUID < ActiveRecord::Base
-end
-
 class PostgresqlLtree < ActiveRecord::Base
 end
 
@@ -68,14 +65,11 @@ class PostgresqlDataTypeTest < ActiveRecord::TestCase
     @first_oid = PostgresqlOid.find(1)
 
     @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
-
-    @connection.execute("INSERT INTO postgresql_uuids (id, guid, compact_guid) VALUES(1, 'd96c3da0-96c1-012f-1316-64ce8f32c6d8', 'f06c715096c1012f131764ce8f32c6d8')")
-    @first_uuid = PostgresqlUUID.find(1)
   end
 
   def teardown
     [PostgresqlArray, PostgresqlTsvector, PostgresqlMoney, PostgresqlNumber, PostgresqlTime, PostgresqlNetworkAddress,
-     PostgresqlBitString, PostgresqlOid, PostgresqlTimestampWithZone, PostgresqlUUID].each(&:delete_all)
+     PostgresqlBitString, PostgresqlOid, PostgresqlTimestampWithZone].each(&:delete_all)
   end
 
   def test_array_escaping
@@ -124,10 +118,6 @@ class PostgresqlDataTypeTest < ActiveRecord::TestCase
     assert_equal :integer, @first_oid.column_for_attribute(:obj_id).type
   end
 
-  def test_data_type_of_uuid_types
-    assert_equal :uuid, @first_uuid.column_for_attribute(:guid).type
-  end
-
   def test_array_values
    assert_equal [35000,21000,18000,17000], @first_array.commission_by_quarter
    assert_equal ['foo','bar','baz'], @first_array.nicknames
@@ -180,11 +170,6 @@ class PostgresqlDataTypeTest < ActiveRecord::TestCase
     assert_equal '01:23:45:67:89:0a', @first_network_address.mac_address
   end
 
-  def test_uuid_values
-    assert_equal 'd96c3da0-96c1-012f-1316-64ce8f32c6d8', @first_uuid.guid
-    assert_equal 'f06c7150-96c1-012f-1317-64ce8f32c6d8', @first_uuid.compact_guid
-  end
-
   def test_bit_string_values
     assert_equal '00010101', @first_bit_string.bit_string
     assert_equal '00010101', @first_bit_string.bit_string_varying
diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index 3f5d981444..f3625c2fc8 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -5,6 +5,41 @@ require 'active_record/base'
 require 'active_record/connection_adapters/postgresql_adapter'
 
 class PostgresqlUUIDTest < ActiveRecord::TestCase
+  class UUIDType < ActiveRecord::Base
+    self.table_name = "uuid_data_type"
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.transaction do
+      @connection.create_table "uuid_data_type" do |t|
+        t.uuid 'guid'
+      end
+    end
+  end
+
+  def teardown
+    @connection.execute 'drop table if exists uuid_data_type'
+  end
+
+  def test_data_type_of_uuid_types
+    assert_equal :uuid, UUIDType.columns_hash["guid"].type
+  end
+
+  def test_uuid_formats
+    ["A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11",
+     "{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11}",
+     "a0eebc999c0b4ef8bb6d6bb9bd380a11",
+     "a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11",
+     "{a0eebc99-9c0b4ef8-bb6d6bb9-bd380a11}"].each do |valid_uuid|
+      UUIDType.create(guid: valid_uuid)
+      uuid = UUIDType.last
+      assert_equal "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", uuid.guid
+    end
+  end
+end
+
+class PostgresqlUUIDGenerationTest < ActiveRecord::TestCase
   class UUID < ActiveRecord::Base
     self.table_name = 'pg_uuids'
   end
-- 
cgit v1.2.3


From 671e997e5a71fbe0ba44d589b34c48b6c6502323 Mon Sep 17 00:00:00 2001
From: Yves Senn <yves.senn@gmail.com>
Date: Wed, 26 Feb 2014 16:04:37 +0100
Subject: extract common code in `uuid_test.rb`.

---
 .../test/cases/adapters/postgresql/uuid_test.rb    | 117 ++++++++++-----------
 1 file changed, 57 insertions(+), 60 deletions(-)

(limited to 'activerecord/test')

diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index f3625c2fc8..f581c4cf39 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -4,22 +4,40 @@ require "cases/helper"
 require 'active_record/base'
 require 'active_record/connection_adapters/postgresql_adapter'
 
+module PostgresqlUUIDHelper
+  def connection
+    @connection ||= ActiveRecord::Base.connection
+  end
+
+  def enable_uuid_ossp
+    unless connection.extension_enabled?('uuid-ossp')
+      connection.enable_extension 'uuid-ossp'
+      connection.commit_db_transaction
+    end
+
+    connection.reconnect!
+  end
+
+  def drop_table(name)
+    connection.execute "drop table if exists #{name}"
+  end
+end
+
 class PostgresqlUUIDTest < ActiveRecord::TestCase
+  include PostgresqlUUIDHelper
+
   class UUIDType < ActiveRecord::Base
     self.table_name = "uuid_data_type"
   end
 
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.transaction do
-      @connection.create_table "uuid_data_type" do |t|
-        t.uuid 'guid'
-      end
+  setup do
+    connection.create_table "uuid_data_type" do |t|
+      t.uuid 'guid'
     end
   end
 
-  def teardown
-    @connection.execute 'drop table if exists uuid_data_type'
+  teardown do
+    drop_table "uuid_data_type"
   end
 
   def test_data_type_of_uuid_types
@@ -40,30 +58,23 @@ class PostgresqlUUIDTest < ActiveRecord::TestCase
 end
 
 class PostgresqlUUIDGenerationTest < ActiveRecord::TestCase
+  include PostgresqlUUIDHelper
+
   class UUID < ActiveRecord::Base
     self.table_name = 'pg_uuids'
   end
 
-  def setup
-    @connection = ActiveRecord::Base.connection
+  setup do
+    enable_uuid_ossp
 
-    unless @connection.extension_enabled?('uuid-ossp')
-      @connection.enable_extension 'uuid-ossp'
-      @connection.commit_db_transaction
-    end
-
-    @connection.reconnect!
-
-    @connection.transaction do
-      @connection.create_table('pg_uuids', id: :uuid, default: 'uuid_generate_v1()') do |t|
-        t.string 'name'
-        t.uuid 'other_uuid', default: 'uuid_generate_v4()'
-      end
+    connection.create_table('pg_uuids', id: :uuid, default: 'uuid_generate_v1()') do |t|
+      t.string 'name'
+      t.uuid 'other_uuid', default: 'uuid_generate_v4()'
     end
   end
 
-  def teardown
-    @connection.execute 'drop table if exists pg_uuids'
+  teardown do
+    drop_table "pg_uuids"
   end
 
   if ActiveRecord::Base.connection.supports_extensions?
@@ -84,14 +95,14 @@ class PostgresqlUUIDGenerationTest < ActiveRecord::TestCase
     end
 
     def test_pk_and_sequence_for_uuid_primary_key
-      pk, seq = @connection.pk_and_sequence_for('pg_uuids')
+      pk, seq = connection.pk_and_sequence_for('pg_uuids')
       assert_equal 'id', pk
       assert_equal nil, seq
     end
 
     def test_schema_dumper_for_uuid_primary_key
       schema = StringIO.new
-      ActiveRecord::SchemaDumper.dump(@connection, schema)
+      ActiveRecord::SchemaDumper.dump(connection, schema)
       assert_match(/\bcreate_table "pg_uuids", id: :uuid, default: "uuid_generate_v1\(\)"/, schema.string)
       assert_match(/t\.uuid   "other_uuid", default: "uuid_generate_v4\(\)"/, schema.string)
     end
@@ -99,34 +110,24 @@ class PostgresqlUUIDGenerationTest < ActiveRecord::TestCase
 end
 
 class PostgresqlUUIDTestNilDefault < ActiveRecord::TestCase
-  class UUID < ActiveRecord::Base
-    self.table_name = 'pg_uuids'
-  end
+  include PostgresqlUUIDHelper
 
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.reconnect!
+  setup do
+    enable_uuid_ossp
 
-    unless @connection.extension_enabled?('uuid-ossp')
-      @connection.enable_extension 'uuid-ossp'
-      @connection.commit_db_transaction
-    end
-
-    @connection.transaction do
-      @connection.create_table('pg_uuids', id: false) do |t|
-        t.primary_key :id, :uuid, default: nil
-        t.string 'name'
-      end
+    connection.create_table('pg_uuids', id: false) do |t|
+      t.primary_key :id, :uuid, default: nil
+      t.string 'name'
     end
   end
 
-  def teardown
-    @connection.execute 'drop table if exists pg_uuids'
+  teardown do
+    drop_table "pg_uuids"
   end
 
   if ActiveRecord::Base.connection.supports_extensions?
     def test_id_allows_default_override_via_nil
-      col_desc = @connection.execute("SELECT pg_get_expr(d.adbin, d.adrelid) as default
+      col_desc = connection.execute("SELECT pg_get_expr(d.adbin, d.adrelid) as default
                                     FROM pg_attribute a
                                     LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
                                     WHERE a.attname='id' AND a.attrelid = 'pg_uuids'::regclass").first
@@ -136,6 +137,8 @@ class PostgresqlUUIDTestNilDefault < ActiveRecord::TestCase
 end
 
 class PostgresqlUUIDTestInverseOf < ActiveRecord::TestCase
+  include PostgresqlUUIDHelper
+
   class UuidPost < ActiveRecord::Base
     self.table_name = 'pg_uuid_posts'
     has_many :uuid_comments, inverse_of: :uuid_post
@@ -146,30 +149,24 @@ class PostgresqlUUIDTestInverseOf < ActiveRecord::TestCase
     belongs_to :uuid_post
   end
 
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.reconnect!
-
-    unless @connection.extension_enabled?('uuid-ossp')
-      @connection.enable_extension 'uuid-ossp'
-      @connection.commit_db_transaction
-    end
+  setup do
+    enable_uuid_ossp
 
-    @connection.transaction do
-      @connection.create_table('pg_uuid_posts', id: :uuid) do |t|
+    connection.transaction do
+      connection.create_table('pg_uuid_posts', id: :uuid) do |t|
         t.string 'title'
       end
-      @connection.create_table('pg_uuid_comments', id: :uuid) do |t|
+      connection.create_table('pg_uuid_comments', id: :uuid) do |t|
         t.uuid :uuid_post_id, default: 'uuid_generate_v4()'
         t.string 'content'
       end
     end
   end
 
-  def teardown
-    @connection.transaction do
-      @connection.execute 'drop table if exists pg_uuid_comments'
-      @connection.execute 'drop table if exists pg_uuid_posts'
+  teardown do
+    connection.transaction do
+      drop_table "pg_uuid_comments"
+      drop_table "pg_uuid_posts"
     end
   end
 
-- 
cgit v1.2.3