1 files changed, 40 insertions, 29 deletions

diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 4b18c37d27..633654a961 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -19,33 +19,12 @@ module ActiveRecord
       assert !relation.loaded, 'relation is not loaded'
     end
 
-    def test_single_values
-      assert_equal [:limit, :offset, :lock, :readonly, :from, :reordering, :reverse_order, :uniq].map(&:to_s).sort,
-        Relation::SINGLE_VALUE_METHODS.map(&:to_s).sort
-    end
-
     def test_initialize_single_values
       relation = Relation.new :a, :b
-      Relation::SINGLE_VALUE_METHODS.each do |method|
+      (Relation::SINGLE_VALUE_METHODS - [:create_with]).each do |method|
         assert_nil relation.send("#{method}_value"), method.to_s
       end
-    end
-
-    def test_association_methods
-      assert_equal [:includes, :eager_load, :preload].map(&:to_s).sort,
-        Relation::ASSOCIATION_METHODS.map(&:to_s).sort
-    end
-
-    def test_initialize_association_methods
-      relation = Relation.new :a, :b
-      Relation::ASSOCIATION_METHODS.each do |method|
-        assert_equal [], relation.send("#{method}_values"), method.to_s
-      end
-    end
-
-    def test_multi_value_methods
-      assert_equal [:select, :group, :order, :joins, :where, :having, :bind, :references].map(&:to_s).sort,
-        Relation::MULTI_VALUE_METHODS.map(&:to_s).sort
+      assert_equal({}, relation.create_with_value)
     end
 
     def test_multi_value_initialize
@@ -154,6 +133,22 @@ module ActiveRecord
       relation = relation.apply_finder_options(:references => :foo)
       assert_equal ['foo'], relation.references_values
     end
+
+    test 'merging a hash into a relation' do
+      relation = Relation.new :a, :b
+      relation = relation.merge where: ['lol'], readonly: true
+
+      assert_equal ['lol'], relation.where_values
+      assert_equal true, relation.readonly_value
+    end
+
+    test 'merging an empty hash into a relation' do
+      assert_equal [], Relation.new(:a, :b).merge({}).where_values
+    end
+
+    test 'merging a hash with unknown keys raises' do
+      assert_raises(ArgumentError) { Relation::HashMerger.new(nil, omg: 'lol') }
+    end
   end
 
   class RelationMutationTest < ActiveSupport::TestCase
@@ -161,7 +156,7 @@ module ActiveRecord
       @relation ||= Relation.new :a, :b
     end
 
-    (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS - [:references]).each do |method|
+    (Relation::MULTI_VALUE_METHODS - [:references, :extending]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal [:foo], relation.public_send("#{method}_values")
@@ -173,7 +168,20 @@ module ActiveRecord
       assert relation.references_values.include?('foo')
     end
 
-    (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order]).each do |method|
+    test 'extending!' do
+      mod = Module.new
+
+      assert relation.extending!(mod).equal?(relation)
+      assert [mod], relation.extending_values
+      assert relation.is_a?(mod)
+    end
+
+    test 'extending! with empty args' do
+      relation.extending!
+      assert_equal [], relation.extending_values
+    end
+
+    (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order, :create_with]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal :foo, relation.public_send("#{method}_value")
@@ -200,11 +208,14 @@ module ActiveRecord
       assert !relation.reverse_order_value
     end
 
-    test 'extending!' do
-      mod = Module.new
+    test 'create_with!' do
+      assert relation.create_with!(foo: 'bar').equal?(relation)
+      assert_equal({foo: 'bar'}, relation.create_with_value)
+    end
 
-      assert relation.extending!(mod).equal?(relation)
-      assert relation.is_a?(mod)
+    test 'merge!' do
+      assert relation.merge!(where: ['foo']).equal?(relation)
+      assert_equal ['foo'], relation.where_values
     end
   end
 end