ibm_db 3.0.3-x86-mingw32 → 5.0.3-x86-mingw32

data/test/cases/relation/delegation_test.rb

@@ -1,68 +1,63 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/comment'
-
-module ActiveRecord
-  class DelegationTest < ActiveRecord::TestCase
-    fixtures :posts
-
-    def call_method(target, method)
-      method_arity = target.to_a.method(method).arity
-
-      if method_arity.zero?
-        target.public_send(method)
-      elsif method_arity < 0
-        if method == :shuffle!
-          target.public_send(method)
-        else
-          target.public_send(method, 1)
-        end
-       elsif method_arity == 1
-        target.public_send(method, 1)
-      else
-        raise NotImplementedError
-      end
-    end
-  end
-
-  module DelegationWhitelistBlacklistTests
-    ARRAY_DELEGATES = [
-      :+, :-, :|, :&, :[],
-      :all?, :collect, :compact, :detect, :each, :each_cons, :each_with_index,
-      :exclude?, :find_all, :flat_map, :group_by, :include?, :length,
-      :map, :none?, :one?, :partition, :reject, :reverse,
-      :sample, :second, :sort, :sort_by, :third,
-      :to_ary, :to_set, :to_xml, :to_yaml, :join
-    ]
-
-    ARRAY_DELEGATES.each do |method|
-      define_method "test_delegates_#{method}_to_Array" do
-        assert_respond_to target, method
-      end
-    end
-
-    ActiveRecord::Delegation::BLACKLISTED_ARRAY_METHODS.each do |method|
-      define_method "test_#{method}_is_not_delegated_to_Array" do
-        assert_raises(NoMethodError) { call_method(target, method) }
-      end
-    end
-  end
-
-  class DelegationAssociationTest < DelegationTest
-    include DelegationWhitelistBlacklistTests
-
-    def target
-      Post.first.comments
-    end
-  end
-
-  class DelegationRelationTest < DelegationTest
-    include DelegationWhitelistBlacklistTests
-
-    fixtures :comments
-
-    def target
-      Comment.all
-    end
-  end
-end
+require 'cases/helper'
+require 'models/post'
+require 'models/comment'
+
+module ActiveRecord
+  class DelegationTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    def call_method(target, method)
+      method_arity = target.to_a.method(method).arity
+
+      if method_arity.zero?
+        target.public_send(method)
+      elsif method_arity < 0
+        if method == :shuffle!
+          target.public_send(method)
+        else
+          target.public_send(method, 1)
+        end
+       elsif method_arity == 1
+        target.public_send(method, 1)
+      else
+        raise NotImplementedError
+      end
+    end
+  end
+
+  module DelegationWhitelistBlacklistTests
+    ARRAY_DELEGATES = [
+      :+, :-, :|, :&, :[], :shuffle,
+      :all?, :collect, :compact, :detect, :each, :each_cons, :each_with_index,
+      :exclude?, :find_all, :flat_map, :group_by, :include?, :length,
+      :map, :none?, :one?, :partition, :reject, :reverse,
+      :sample, :second, :sort, :sort_by, :third,
+      :to_ary, :to_set, :to_xml, :to_yaml, :join,
+      :in_groups, :in_groups_of, :to_sentence, :to_formatted_s
+    ]
+
+    ARRAY_DELEGATES.each do |method|
+      define_method "test_delegates_#{method}_to_Array" do
+        assert_respond_to target, method
+      end
+    end
+  end
+
+  class DelegationAssociationTest < DelegationTest
+    include DelegationWhitelistBlacklistTests
+
+    def target
+      Post.first.comments
+    end
+  end
+
+  class DelegationRelationTest < DelegationTest
+    include DelegationWhitelistBlacklistTests
+
+    fixtures :comments
+
+    def target
+      Comment.all
+    end
+  end
+end

data/test/cases/relation/merging_test.rb

@@ -1,161 +1,157 @@
-require 'cases/helper'
-require 'models/author'
-require 'models/comment'
-require 'models/developer'
-require 'models/computer'
-require 'models/post'
-require 'models/project'
-require 'models/rating'
-
-class RelationMergingTest < ActiveRecord::TestCase
-  fixtures :developers, :comments, :authors, :posts, :author_addresses
-
-  def test_relation_merging
-    devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order('id ASC').where("id < 3"))
-    assert_equal [developers(:david), developers(:jamis)], devs.to_a
-
-    dev_with_count = Developer.limit(1).merge(Developer.order('id DESC')).merge(Developer.select('developers.*'))
-    assert_equal [developers(:poor_jamis)], dev_with_count.to_a
-  end
-
-  def test_relation_to_sql
-    post = Post.first
-    sql = post.comments.to_sql
-    assert_match(/.?post_id.? = #{post.id}\Z/i, sql)
-  end
-
-  def test_relation_merging_with_arel_equalities_keeps_last_equality
-    devs = Developer.where(Developer.arel_table[:salary].eq(80000)).merge(
-      Developer.where(Developer.arel_table[:salary].eq(9000))
-    )
-    assert_equal [developers(:poor_jamis)], devs.to_a
-  end
-
-  def test_relation_merging_with_arel_equalities_keeps_last_equality_with_non_attribute_left_hand
-    salary_attr = Developer.arel_table[:salary]
-    devs = Developer.where(
-      Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(80000)
-    ).merge(
-      Developer.where(
-        Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(9000)
-      )
-    )
-    assert_equal [developers(:poor_jamis)], devs.to_a
-  end
-
-  def test_relation_merging_with_eager_load
-    relations = []
-    relations << Post.order('comments.id DESC').merge(Post.eager_load(:last_comment)).merge(Post.all)
-    relations << Post.eager_load(:last_comment).merge(Post.order('comments.id DESC')).merge(Post.all)
-
-    relations.each do |posts|
-      post = posts.find { |p| p.id == 1 }
-      assert_equal Post.find(1).last_comment, post.last_comment
-    end
-  end
-
-  def test_relation_merging_with_locks
-    devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
-    assert devs.locked.present?
-  end
-
-  def test_relation_merging_with_preload
-    [Post.all.merge(Post.preload(:author)), Post.preload(:author).merge(Post.all)].each do |posts|
-      assert_queries(2) { assert posts.first.author }
-    end
-  end
-
-  def test_relation_merging_with_joins
-    comments = Comment.joins(:post).where(:body => 'Thank you for the welcome').merge(Post.where(:body => 'Such a lovely day'))
-    assert_equal 1, comments.count
-  end
-
-  def test_relation_merging_with_association
-    assert_queries(2) do  # one for loading post, and another one merged query
-      post = Post.where(:body => 'Such a lovely day').first
-      comments = Comment.where(:body => 'Thank you for the welcome').merge(post.comments)
-      assert_equal 1, comments.count
-    end
-  end
-
-  test "merge collapses wheres from the LHS only" do
-    left  = Post.where(title: "omg").where(comments_count: 1)
-    right = Post.where(title: "wtf").where(title: "bbq")
-
-    expected = [left.bind_values[1]] + right.bind_values
-    merged   = left.merge(right)
-
-    assert_equal expected, merged.bind_values
-    assert !merged.to_sql.include?("omg")
-    assert merged.to_sql.include?("wtf")
-    assert merged.to_sql.include?("bbq")
-  end
-
-  def test_merging_keeps_lhs_bind_parameters
-    column = Post.columns_hash['id']
-    binds = [[column, 20]]
-
-    right  = Post.where(id: 20)
-    left   = Post.where(id: 10)
-
-    merged = left.merge(right)
-    assert_equal binds, merged.bind_values
-  end
-
-  def test_merging_reorders_bind_params
-    post  = Post.first
-    right = Post.where(id: 1)
-    left  = Post.where(title: post.title)
-
-    merged = left.merge(right)
-    assert_equal post, merged.first
-  end
-
-  def test_merging_compares_symbols_and_strings_as_equal
-    post = PostThatLoadsCommentsInAnAfterSaveHook.create!(title: "First Post", body: "Blah blah blah.")
-    assert_equal "First comment!", post.comments.where(body: "First comment!").first_or_create.body
-  end
-end
-
-class MergingDifferentRelationsTest < ActiveRecord::TestCase
-  fixtures :posts, :authors, :developers
-
-  test "merging where relations" do
-    hello_by_bob = Post.where(body: "hello").joins(:author).
-      merge(Author.where(name: "Bob")).order("posts.id").pluck("posts.id")
-
-    assert_equal [posts(:misc_by_bob).id,
-                  posts(:other_by_bob).id], hello_by_bob
-  end
-
-  test "merging order relations" do
-    posts_by_author_name = Post.limit(3).joins(:author).
-      merge(Author.order(:name)).pluck("authors.name")
-
-    assert_equal ["Bob", "Bob", "David"], posts_by_author_name
-
-    posts_by_author_name = Post.limit(3).joins(:author).
-      merge(Author.order("name")).pluck("authors.name")
-
-    assert_equal ["Bob", "Bob", "David"], posts_by_author_name
-  end
-
-  test "merging order relations (using a hash argument)" do
-    posts_by_author_name = Post.limit(4).joins(:author).
-      merge(Author.order(name: :desc)).pluck("authors.name")
-
-    assert_equal ["Mary", "Mary", "Mary", "David"], posts_by_author_name
-  end
-
-  test "relation merging (using a proc  argument)" do
-    dev = Developer.where(name: "Jamis").first
-
-    comment_1 = dev.comments.create!(body: "I'm Jamis", post: Post.first)
-    rating_1 = comment_1.ratings.create!
-
-    comment_2 = dev.comments.create!(body: "I'm John", post: Post.first)
-    comment_2.ratings.create!
-
-    assert_equal dev.ratings, [rating_1]
-  end
-end
+require 'cases/helper'
+require 'models/author'
+require 'models/comment'
+require 'models/developer'
+require 'models/computer'
+require 'models/post'
+require 'models/project'
+require 'models/rating'
+
+class RelationMergingTest < ActiveRecord::TestCase
+  fixtures :developers, :comments, :authors, :posts
+
+  def test_relation_merging
+    devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order('id ASC').where("id < 3"))
+    assert_equal [developers(:david), developers(:jamis)], devs.to_a
+
+    dev_with_count = Developer.limit(1).merge(Developer.order('id DESC')).merge(Developer.select('developers.*'))
+    assert_equal [developers(:poor_jamis)], dev_with_count.to_a
+  end
+
+  def test_relation_to_sql
+    post = Post.first
+    sql = post.comments.to_sql
+    assert_match(/.?post_id.? = #{post.id}\Z/i, sql)
+  end
+
+  def test_relation_merging_with_arel_equalities_keeps_last_equality
+    devs = Developer.where(Developer.arel_table[:salary].eq(80000)).merge(
+      Developer.where(Developer.arel_table[:salary].eq(9000))
+    )
+    assert_equal [developers(:poor_jamis)], devs.to_a
+  end
+
+  def test_relation_merging_with_arel_equalities_keeps_last_equality_with_non_attribute_left_hand
+    salary_attr = Developer.arel_table[:salary]
+    devs = Developer.where(
+      Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(80000)
+    ).merge(
+      Developer.where(
+        Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(9000)
+      )
+    )
+    assert_equal [developers(:poor_jamis)], devs.to_a
+  end
+
+  def test_relation_merging_with_eager_load
+    relations = []
+    relations << Post.order('comments.id DESC').merge(Post.eager_load(:last_comment)).merge(Post.all)
+    relations << Post.eager_load(:last_comment).merge(Post.order('comments.id DESC')).merge(Post.all)
+
+    relations.each do |posts|
+      post = posts.find { |p| p.id == 1 }
+      assert_equal Post.find(1).last_comment, post.last_comment
+    end
+  end
+
+  def test_relation_merging_with_locks
+    devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
+    assert devs.locked.present?
+  end
+
+  def test_relation_merging_with_preload
+    [Post.all.merge(Post.preload(:author)), Post.preload(:author).merge(Post.all)].each do |posts|
+      assert_queries(2) { assert posts.first.author }
+    end
+  end
+
+  def test_relation_merging_with_joins
+    comments = Comment.joins(:post).where(:body => 'Thank you for the welcome').merge(Post.where(:body => 'Such a lovely day'))
+    assert_equal 1, comments.count
+  end
+
+  def test_relation_merging_with_association
+    assert_queries(2) do  # one for loading post, and another one merged query
+      post = Post.where(:body => 'Such a lovely day').first
+      comments = Comment.where(:body => 'Thank you for the welcome').merge(post.comments)
+      assert_equal 1, comments.count
+    end
+  end
+
+  test "merge collapses wheres from the LHS only" do
+    left  = Post.where(title: "omg").where(comments_count: 1)
+    right = Post.where(title: "wtf").where(title: "bbq")
+
+    expected = [left.bound_attributes[1]] + right.bound_attributes
+    merged   = left.merge(right)
+
+    assert_equal expected, merged.bound_attributes
+    assert !merged.to_sql.include?("omg")
+    assert merged.to_sql.include?("wtf")
+    assert merged.to_sql.include?("bbq")
+  end
+
+  def test_merging_reorders_bind_params
+    post  = Post.first
+    right = Post.where(id: 1)
+    left  = Post.where(title: post.title)
+
+    merged = left.merge(right)
+    assert_equal post, merged.first
+  end
+
+  def test_merging_compares_symbols_and_strings_as_equal
+    post = PostThatLoadsCommentsInAnAfterSaveHook.create!(title: "First Post", body: "Blah blah blah.")
+    assert_equal "First comment!", post.comments.where(body: "First comment!").first_or_create.body
+  end
+
+  def test_merging_with_from_clause
+    relation = Post.all
+    assert relation.from_clause.empty?
+    relation = relation.merge(Post.from("posts"))
+    refute relation.from_clause.empty?
+  end
+end
+
+class MergingDifferentRelationsTest < ActiveRecord::TestCase
+  fixtures :posts, :authors, :developers
+
+  test "merging where relations" do
+    hello_by_bob = Post.where(body: "hello").joins(:author).
+      merge(Author.where(name: "Bob")).order("posts.id").pluck("posts.id")
+
+    assert_equal [posts(:misc_by_bob).id,
+                  posts(:other_by_bob).id], hello_by_bob
+  end
+
+  test "merging order relations" do
+    posts_by_author_name = Post.limit(3).joins(:author).
+      merge(Author.order(:name)).pluck("authors.name")
+
+    assert_equal ["Bob", "Bob", "David"], posts_by_author_name
+
+    posts_by_author_name = Post.limit(3).joins(:author).
+      merge(Author.order("name")).pluck("authors.name")
+
+    assert_equal ["Bob", "Bob", "David"], posts_by_author_name
+  end
+
+  test "merging order relations (using a hash argument)" do
+    posts_by_author_name = Post.limit(4).joins(:author).
+      merge(Author.order(name: :desc)).pluck("authors.name")
+
+    assert_equal ["Mary", "Mary", "Mary", "David"], posts_by_author_name
+  end
+
+  test "relation merging (using a proc  argument)" do
+    dev = Developer.where(name: "Jamis").first
+
+    comment_1 = dev.comments.create!(body: "I'm Jamis", post: Post.first)
+    rating_1 = comment_1.ratings.create!
+
+    comment_2 = dev.comments.create!(body: "I'm John", post: Post.first)
+    comment_2.ratings.create!
+
+    assert_equal dev.ratings, [rating_1]
+  end
+end

data/test/cases/relation/mutation_test.rb

@@ -1,165 +1,183 @@
-require 'cases/helper'
-require 'models/post'
-
-module ActiveRecord
-  class RelationMutationTest < ActiveSupport::TestCase
-    class FakeKlass < Struct.new(:table_name, :name)
-      extend ActiveRecord::Delegation::DelegateCache
-      inherited self
-
-      def connection
-        Post.connection
-      end
-
-      def relation_delegate_class(klass)
-        self.class.relation_delegate_class(klass)
-      end
-
-      def attribute_alias?(name)
-        false
-      end
-
-      def sanitize_sql(sql)
-        sql
-      end
-    end
-
-    def relation
-      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table
-    end
-
-    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select]).each do |method|
-      test "##{method}!" do
-        assert relation.public_send("#{method}!", :foo).equal?(relation)
-        assert_equal [:foo], relation.public_send("#{method}_values")
-      end
-    end
-
-    test "#_select!" do
-      assert relation.public_send("_select!", :foo).equal?(relation)
-      assert_equal [:foo], relation.public_send("select_values")
-    end
-
-    test '#order!' do
-      assert relation.order!('name ASC').equal?(relation)
-      assert_equal ['name ASC'], relation.order_values
-    end
-
-    test '#order! with symbol prepends the table name' do
-      assert relation.order!(:name).equal?(relation)
-      node = relation.order_values.first
-      assert node.ascending?
-      assert_equal :name, node.expr.name
-      assert_equal "posts", node.expr.relation.name
-    end
-
-    test '#order! on non-string does not attempt regexp match for references' do
-      obj = Object.new
-      obj.expects(:=~).never
-      assert relation.order!(obj)
-      assert_equal [obj], relation.order_values
-    end
-
-    test '#references!' do
-      assert relation.references!(:foo).equal?(relation)
-      assert relation.references_values.include?('foo')
-    end
-
-    test 'extending!' do
-      mod, mod2 = Module.new, Module.new
-
-      assert relation.extending!(mod).equal?(relation)
-      assert_equal [mod], relation.extending_values
-      assert relation.is_a?(mod)
-
-      relation.extending!(mod2)
-      assert_equal [mod, mod2], relation.extending_values
-    end
-
-    test 'extending! with empty args' do
-      relation.extending!
-      assert_equal [], relation.extending_values
-    end
-
-    (Relation::SINGLE_VALUE_METHODS - [:from, :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")
-      end
-    end
-
-    test '#from!' do
-      assert relation.from!('foo').equal?(relation)
-      assert_equal ['foo', nil], relation.from_value
-    end
-
-    test '#lock!' do
-      assert relation.lock!('foo').equal?(relation)
-      assert_equal 'foo', relation.lock_value
-    end
-
-    test '#reorder!' do
-      order_relation = self.relation.order('foo')
-
-      assert order_relation.reorder!('bar').equal?(order_relation)
-      assert_equal ['bar'], order_relation.order_values
-      assert order_relation.reordering_value
-    end
-
-    test '#reorder! with symbol prepends the table name' do
-      assert relation.reorder!(:name).equal?(relation)
-      node = relation.order_values.first
-
-      assert node.ascending?
-      assert_equal :name, node.expr.name
-      assert_equal "posts", node.expr.relation.name
-    end
-
-    test 'reverse_order!' do
-      order_relation = Post.order('title ASC, comments_count DESC')
-
-      order_relation.reverse_order!
-
-      assert_equal 'title DESC', order_relation.order_values.first
-      assert_equal 'comments_count ASC', order_relation.order_values.last
-
-
-      order_relation.reverse_order!
-
-      assert_equal 'title ASC', order_relation.order_values.first
-      assert_equal 'comments_count DESC', order_relation.order_values.last
-    end
-
-    test 'create_with!' do
-      assert relation.create_with!(foo: 'bar').equal?(relation)
-      assert_equal({foo: 'bar'}, relation.create_with_value)
-    end
-
-    test 'test_merge!' do
-      assert relation.merge!(where: :foo).equal?(relation)
-      assert_equal [:foo], relation.where_values
-    end
-
-    test 'merge with a proc' do
-      assert_equal [:foo], relation.merge(-> { where(:foo) }).where_values
-    end
-
-    test 'none!' do
-      assert relation.none!.equal?(relation)
-      assert_equal [NullRelation], relation.extending_values
-      assert relation.is_a?(NullRelation)
-    end
-
-    test 'distinct!' do
-      relation.distinct! :foo
-      assert_equal :foo, relation.distinct_value
-      assert_equal :foo, relation.uniq_value # deprecated access
-    end
-
-    test 'uniq! was replaced by distinct!' do
-      relation.uniq! :foo
-      assert_equal :foo, relation.distinct_value
-      assert_equal :foo, relation.uniq_value # deprecated access
-    end
-  end
-end
+require 'cases/helper'
+require 'models/post'
+
+module ActiveRecord
+  class RelationMutationTest < ActiveSupport::TestCase
+    class FakeKlass < Struct.new(:table_name, :name)
+      extend ActiveRecord::Delegation::DelegateCache
+      inherited self
+
+      def connection
+        Post.connection
+      end
+
+      def relation_delegate_class(klass)
+        self.class.relation_delegate_class(klass)
+      end
+
+      def attribute_alias?(name)
+        false
+      end
+
+      def sanitize_sql(sql)
+        sql
+      end
+
+      def sanitize_sql_for_order(sql)
+        sql
+      end
+
+      def arel_attribute(name, table)
+        table[name]
+      end
+    end
+
+    def relation
+      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table, Post.predicate_builder
+    end
+
+    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select, :left_joins]).each do |method|
+      test "##{method}!" do
+        assert relation.public_send("#{method}!", :foo).equal?(relation)
+        assert_equal [:foo], relation.public_send("#{method}_values")
+      end
+    end
+
+    test "#_select!" do
+      assert relation.public_send("_select!", :foo).equal?(relation)
+      assert_equal [:foo], relation.public_send("select_values")
+    end
+
+    test '#order!' do
+      assert relation.order!('name ASC').equal?(relation)
+      assert_equal ['name ASC'], relation.order_values
+    end
+
+    test '#order! with symbol prepends the table name' do
+      assert relation.order!(:name).equal?(relation)
+      node = relation.order_values.first
+      assert node.ascending?
+      assert_equal :name, node.expr.name
+      assert_equal "posts", node.expr.relation.name
+    end
+
+    test '#order! on non-string does not attempt regexp match for references' do
+      obj = Object.new
+      assert_not_called(obj, :=~) do
+        assert relation.order!(obj)
+        assert_equal [obj], relation.order_values
+      end
+    end
+
+    test '#references!' do
+      assert relation.references!(:foo).equal?(relation)
+      assert relation.references_values.include?('foo')
+    end
+
+    test 'extending!' do
+      mod, mod2 = Module.new, Module.new
+
+      assert relation.extending!(mod).equal?(relation)
+      assert_equal [mod], relation.extending_values
+      assert relation.is_a?(mod)
+
+      relation.extending!(mod2)
+      assert_equal [mod, mod2], relation.extending_values
+    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, :uniq]).each do |method|
+      test "##{method}!" do
+        assert relation.public_send("#{method}!", :foo).equal?(relation)
+        assert_equal :foo, relation.public_send("#{method}_value")
+      end
+    end
+
+    test '#from!' do
+      assert relation.from!('foo').equal?(relation)
+      assert_equal 'foo', relation.from_clause.value
+    end
+
+    test '#lock!' do
+      assert relation.lock!('foo').equal?(relation)
+      assert_equal 'foo', relation.lock_value
+    end
+
+    test '#reorder!' do
+      @relation = self.relation.order('foo')
+
+      assert relation.reorder!('bar').equal?(relation)
+      assert_equal ['bar'], relation.order_values
+      assert relation.reordering_value
+    end
+
+    test '#reorder! with symbol prepends the table name' do
+      assert relation.reorder!(:name).equal?(relation)
+      node = relation.order_values.first
+
+      assert node.ascending?
+      assert_equal :name, node.expr.name
+      assert_equal "posts", node.expr.relation.name
+    end
+
+    test 'reverse_order!' do
+      @relation = Post.order('title ASC, comments_count DESC')
+
+      relation.reverse_order!
+
+      assert_equal 'title DESC', relation.order_values.first
+      assert_equal 'comments_count ASC', relation.order_values.last
+
+
+      relation.reverse_order!
+
+      assert_equal 'title ASC', relation.order_values.first
+      assert_equal 'comments_count DESC', relation.order_values.last
+    end
+
+    test 'create_with!' do
+      assert relation.create_with!(foo: 'bar').equal?(relation)
+      assert_equal({foo: 'bar'}, relation.create_with_value)
+    end
+
+    test 'test_merge!' do
+      assert relation.merge!(select: :foo).equal?(relation)
+      assert_equal [:foo], relation.select_values
+    end
+
+    test 'merge with a proc' do
+      assert_equal [:foo], relation.merge(-> { select(:foo) }).select_values
+    end
+
+    test 'none!' do
+      assert relation.none!.equal?(relation)
+      assert_equal [NullRelation], relation.extending_values
+      assert relation.is_a?(NullRelation)
+    end
+
+    test 'distinct!' do
+      relation.distinct! :foo
+      assert_equal :foo, relation.distinct_value
+
+      assert_deprecated do
+        assert_equal :foo, relation.uniq_value # deprecated access
+      end
+    end
+
+    test 'uniq! was replaced by distinct!' do
+      assert_deprecated(/use distinct! instead/) do
+        relation.uniq! :foo
+      end
+
+      assert_deprecated(/use distinct_value instead/) do
+        assert_equal :foo, relation.uniq_value # deprecated access
+      end
+
+      assert_equal :foo, relation.distinct_value
+    end
+  end
+end