ibm_db 4.0.0-x86-mingw32 → 5.0.2-x86-mingw32

data/test/cases/relation/where_clause_test.rb

@@ -1,182 +1,182 @@
-require "cases/helper"
-
-class ActiveRecord::Relation
-  class WhereClauseTest < ActiveRecord::TestCase
-    test "+ combines two where clauses" do
-      first_clause = WhereClause.new([table["id"].eq(bind_param)], [["id", 1]])
-      second_clause = WhereClause.new([table["name"].eq(bind_param)], [["name", "Sean"]])
-      combined = WhereClause.new(
-        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
-        [["id", 1], ["name", "Sean"]],
-      )
-
-      assert_equal combined, first_clause + second_clause
-    end
-
-    test "+ is associative, but not commutative" do
-      a = WhereClause.new(["a"], ["bind a"])
-      b = WhereClause.new(["b"], ["bind b"])
-      c = WhereClause.new(["c"], ["bind c"])
-
-      assert_equal a + (b + c), (a + b) + c
-      assert_not_equal a + b, b + a
-    end
-
-    test "an empty where clause is the identity value for +" do
-      clause = WhereClause.new([table["id"].eq(bind_param)], [["id", 1]])
-
-      assert_equal clause, clause + WhereClause.empty
-    end
-
-    test "merge combines two where clauses" do
-      a = WhereClause.new([table["id"].eq(1)], [])
-      b = WhereClause.new([table["name"].eq("Sean")], [])
-      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")], [])
-
-      assert_equal expected, a.merge(b)
-    end
-
-    test "merge keeps the right side, when two equality clauses reference the same column" do
-      a = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")], [])
-      b = WhereClause.new([table["name"].eq("Jim")], [])
-      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Jim")], [])
-
-      assert_equal expected, a.merge(b)
-    end
-
-    test "merge removes bind parameters matching overlapping equality clauses" do
-      a = WhereClause.new(
-        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
-        [attribute("id", 1), attribute("name", "Sean")],
-      )
-      b = WhereClause.new(
-        [table["name"].eq(bind_param)],
-        [attribute("name", "Jim")]
-      )
-      expected = WhereClause.new(
-        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
-        [attribute("id", 1), attribute("name", "Jim")],
-      )
-
-      assert_equal expected, a.merge(b)
-    end
-
-    test "merge allows for columns with the same name from different tables" do
-      skip "This is not possible as of 4.2, and the binds do not yet contain sufficient information for this to happen"
-      # We might be able to change the implementation to remove conflicts by index, rather than column name
-    end
-
-    test "a clause knows if it is empty" do
-      assert WhereClause.empty.empty?
-      assert_not WhereClause.new(["anything"], []).empty?
-    end
-
-    test "invert cannot handle nil" do
-      where_clause = WhereClause.new([nil], [])
-
-      assert_raises ArgumentError do
-        where_clause.invert
-      end
-    end
-
-    test "invert replaces each part of the predicate with its inverse" do
-      random_object = Object.new
-      original = WhereClause.new([
-        table["id"].in([1, 2, 3]),
-        table["id"].eq(1),
-        "sql literal",
-        random_object
-      ], [])
-      expected = WhereClause.new([
-        table["id"].not_in([1, 2, 3]),
-        table["id"].not_eq(1),
-        Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new("sql literal")),
-        Arel::Nodes::Not.new(random_object)
-      ], [])
-
-      assert_equal expected, original.invert
-    end
-
-    test "accept removes binary predicates referencing a given column" do
-      where_clause = WhereClause.new([
-        table["id"].in([1, 2, 3]),
-        table["name"].eq(bind_param),
-        table["age"].gteq(bind_param),
-      ], [
-        attribute("name", "Sean"),
-        attribute("age", 30),
-      ])
-      expected = WhereClause.new([table["age"].gteq(bind_param)], [attribute("age", 30)])
-
-      assert_equal expected, where_clause.except("id", "name")
-    end
-
-    test "ast groups its predicates with AND" do
-      predicates = [
-        table["id"].in([1, 2, 3]),
-        table["name"].eq(bind_param),
-      ]
-      where_clause = WhereClause.new(predicates, [])
-      expected = Arel::Nodes::And.new(predicates)
-
-      assert_equal expected, where_clause.ast
-    end
-
-    test "ast wraps any SQL literals in parenthesis" do
-      random_object = Object.new
-      where_clause = WhereClause.new([
-        table["id"].in([1, 2, 3]),
-        "foo = bar",
-        random_object,
-      ], [])
-      expected = Arel::Nodes::And.new([
-        table["id"].in([1, 2, 3]),
-        Arel::Nodes::Grouping.new(Arel.sql("foo = bar")),
-        Arel::Nodes::Grouping.new(random_object),
-      ])
-
-      assert_equal expected, where_clause.ast
-    end
-
-    test "ast removes any empty strings" do
-      where_clause = WhereClause.new([table["id"].in([1, 2, 3])], [])
-      where_clause_with_empty = WhereClause.new([table["id"].in([1, 2, 3]), ''], [])
-
-      assert_equal where_clause.ast, where_clause_with_empty.ast
-    end
-
-    test "or joins the two clauses using OR" do
-      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
-      other_clause = WhereClause.new([table["name"].eq(bind_param)], [attribute("name", "Sean")])
-      expected_ast =
-        Arel::Nodes::Grouping.new(
-          Arel::Nodes::Or.new(table["id"].eq(bind_param), table["name"].eq(bind_param))
-        )
-      expected_binds = where_clause.binds + other_clause.binds
-
-      assert_equal expected_ast.to_sql, where_clause.or(other_clause).ast.to_sql
-      assert_equal expected_binds, where_clause.or(other_clause).binds
-    end
-
-    test "or returns an empty where clause when either side is empty" do
-      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
-
-      assert_equal WhereClause.empty, where_clause.or(WhereClause.empty)
-      assert_equal WhereClause.empty, WhereClause.empty.or(where_clause)
-    end
-
-    private
-
-    def table
-      Arel::Table.new("table")
-    end
-
-    def bind_param
-      Arel::Nodes::BindParam.new
-    end
-
-    def attribute(name, value)
-      ActiveRecord::Attribute.with_cast_value(name, value, ActiveRecord::Type::Value.new)
-    end
-  end
-end
+require "cases/helper"
+
+class ActiveRecord::Relation
+  class WhereClauseTest < ActiveRecord::TestCase
+    test "+ combines two where clauses" do
+      first_clause = WhereClause.new([table["id"].eq(bind_param)], [["id", 1]])
+      second_clause = WhereClause.new([table["name"].eq(bind_param)], [["name", "Sean"]])
+      combined = WhereClause.new(
+        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
+        [["id", 1], ["name", "Sean"]],
+      )
+
+      assert_equal combined, first_clause + second_clause
+    end
+
+    test "+ is associative, but not commutative" do
+      a = WhereClause.new(["a"], ["bind a"])
+      b = WhereClause.new(["b"], ["bind b"])
+      c = WhereClause.new(["c"], ["bind c"])
+
+      assert_equal a + (b + c), (a + b) + c
+      assert_not_equal a + b, b + a
+    end
+
+    test "an empty where clause is the identity value for +" do
+      clause = WhereClause.new([table["id"].eq(bind_param)], [["id", 1]])
+
+      assert_equal clause, clause + WhereClause.empty
+    end
+
+    test "merge combines two where clauses" do
+      a = WhereClause.new([table["id"].eq(1)], [])
+      b = WhereClause.new([table["name"].eq("Sean")], [])
+      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")], [])
+
+      assert_equal expected, a.merge(b)
+    end
+
+    test "merge keeps the right side, when two equality clauses reference the same column" do
+      a = WhereClause.new([table["id"].eq(1), table["name"].eq("Sean")], [])
+      b = WhereClause.new([table["name"].eq("Jim")], [])
+      expected = WhereClause.new([table["id"].eq(1), table["name"].eq("Jim")], [])
+
+      assert_equal expected, a.merge(b)
+    end
+
+    test "merge removes bind parameters matching overlapping equality clauses" do
+      a = WhereClause.new(
+        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
+        [attribute("id", 1), attribute("name", "Sean")],
+      )
+      b = WhereClause.new(
+        [table["name"].eq(bind_param)],
+        [attribute("name", "Jim")]
+      )
+      expected = WhereClause.new(
+        [table["id"].eq(bind_param), table["name"].eq(bind_param)],
+        [attribute("id", 1), attribute("name", "Jim")],
+      )
+
+      assert_equal expected, a.merge(b)
+    end
+
+    test "merge allows for columns with the same name from different tables" do
+      skip "This is not possible as of 4.2, and the binds do not yet contain sufficient information for this to happen"
+      # We might be able to change the implementation to remove conflicts by index, rather than column name
+    end
+
+    test "a clause knows if it is empty" do
+      assert WhereClause.empty.empty?
+      assert_not WhereClause.new(["anything"], []).empty?
+    end
+
+    test "invert cannot handle nil" do
+      where_clause = WhereClause.new([nil], [])
+
+      assert_raises ArgumentError do
+        where_clause.invert
+      end
+    end
+
+    test "invert replaces each part of the predicate with its inverse" do
+      random_object = Object.new
+      original = WhereClause.new([
+        table["id"].in([1, 2, 3]),
+        table["id"].eq(1),
+        "sql literal",
+        random_object
+      ], [])
+      expected = WhereClause.new([
+        table["id"].not_in([1, 2, 3]),
+        table["id"].not_eq(1),
+        Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new("sql literal")),
+        Arel::Nodes::Not.new(random_object)
+      ], [])
+
+      assert_equal expected, original.invert
+    end
+
+    test "accept removes binary predicates referencing a given column" do
+      where_clause = WhereClause.new([
+        table["id"].in([1, 2, 3]),
+        table["name"].eq(bind_param),
+        table["age"].gteq(bind_param),
+      ], [
+        attribute("name", "Sean"),
+        attribute("age", 30),
+      ])
+      expected = WhereClause.new([table["age"].gteq(bind_param)], [attribute("age", 30)])
+
+      assert_equal expected, where_clause.except("id", "name")
+    end
+
+    test "ast groups its predicates with AND" do
+      predicates = [
+        table["id"].in([1, 2, 3]),
+        table["name"].eq(bind_param),
+      ]
+      where_clause = WhereClause.new(predicates, [])
+      expected = Arel::Nodes::And.new(predicates)
+
+      assert_equal expected, where_clause.ast
+    end
+
+    test "ast wraps any SQL literals in parenthesis" do
+      random_object = Object.new
+      where_clause = WhereClause.new([
+        table["id"].in([1, 2, 3]),
+        "foo = bar",
+        random_object,
+      ], [])
+      expected = Arel::Nodes::And.new([
+        table["id"].in([1, 2, 3]),
+        Arel::Nodes::Grouping.new(Arel.sql("foo = bar")),
+        Arel::Nodes::Grouping.new(random_object),
+      ])
+
+      assert_equal expected, where_clause.ast
+    end
+
+    test "ast removes any empty strings" do
+      where_clause = WhereClause.new([table["id"].in([1, 2, 3])], [])
+      where_clause_with_empty = WhereClause.new([table["id"].in([1, 2, 3]), ''], [])
+
+      assert_equal where_clause.ast, where_clause_with_empty.ast
+    end
+
+    test "or joins the two clauses using OR" do
+      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
+      other_clause = WhereClause.new([table["name"].eq(bind_param)], [attribute("name", "Sean")])
+      expected_ast =
+        Arel::Nodes::Grouping.new(
+          Arel::Nodes::Or.new(table["id"].eq(bind_param), table["name"].eq(bind_param))
+        )
+      expected_binds = where_clause.binds + other_clause.binds
+
+      assert_equal expected_ast.to_sql, where_clause.or(other_clause).ast.to_sql
+      assert_equal expected_binds, where_clause.or(other_clause).binds
+    end
+
+    test "or returns an empty where clause when either side is empty" do
+      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
+
+      assert_equal WhereClause.empty, where_clause.or(WhereClause.empty)
+      assert_equal WhereClause.empty, WhereClause.empty.or(where_clause)
+    end
+
+    private
+
+    def table
+      Arel::Table.new("table")
+    end
+
+    def bind_param
+      Arel::Nodes::BindParam.new
+    end
+
+    def attribute(name, value)
+      ActiveRecord::Attribute.with_cast_value(name, value, ActiveRecord::Type::Value.new)
+    end
+  end
+end

data/test/cases/relation/where_test.rb

@@ -1,322 +1,322 @@
-require "cases/helper"
-require "models/author"
-require "models/binary"
-require "models/cake_designer"
-require "models/car"
-require "models/chef"
-require "models/comment"
-require "models/edge"
-require "models/essay"
-require "models/post"
-require "models/price_estimate"
-require "models/topic"
-require "models/treasure"
-require "models/vertex"
-
-module ActiveRecord
-  class WhereTest < ActiveRecord::TestCase
-    fixtures :posts, :edges, :authors, :binaries, :essays, :cars, :treasures, :price_estimates
-
-    def test_where_copies_bind_params
-      author = authors(:david)
-      posts  = author.posts.where('posts.id != 1')
-      joined = Post.where(id: posts)
-
-      assert_operator joined.length, :>, 0
-
-      joined.each { |post|
-        assert_equal author, post.author
-        assert_not_equal 1, post.id
-      }
-    end
-
-    def test_where_copies_bind_params_in_the_right_order
-      author = authors(:david)
-      posts = author.posts.where.not(id: 1)
-      joined = Post.where(id: posts, title: posts.first.title)
-
-      assert_equal joined, [posts.first]
-    end
-
-    def test_where_copies_arel_bind_params
-      chef = Chef.create!
-      CakeDesigner.create!(chef: chef)
-
-      cake_designers = CakeDesigner.joins(:chef).where(chefs: { id: chef.id })
-      chefs = Chef.where(employable: cake_designers)
-
-      assert_equal [chef], chefs.to_a
-    end
-
-    def test_rewhere_on_root
-      assert_equal posts(:welcome), Post.rewhere(title: 'Welcome to the weblog').first
-    end
-
-    def test_belongs_to_shallow_where
-      author = Author.new
-      author.id = 1
-
-      assert_equal Post.where(author_id: 1).to_sql, Post.where(author: author).to_sql
-    end
-
-    def test_belongs_to_nil_where
-      assert_equal Post.where(author_id: nil).to_sql, Post.where(author: nil).to_sql
-    end
-
-    def test_belongs_to_array_value_where
-      assert_equal Post.where(author_id: [1,2]).to_sql, Post.where(author: [1,2]).to_sql
-    end
-
-    def test_belongs_to_nested_relation_where
-      expected = Post.where(author_id: Author.where(id: [1,2])).to_sql
-      actual   = Post.where(author:    Author.where(id: [1,2])).to_sql
-
-      assert_equal expected, actual
-    end
-
-    def test_belongs_to_nested_where
-      parent = Comment.new
-      parent.id = 1
-
-      expected = Post.where(comments: { parent_id: 1 }).joins(:comments)
-      actual   = Post.where(comments: { parent: parent }).joins(:comments)
-
-      assert_equal expected.to_sql, actual.to_sql
-    end
-
-    def test_belongs_to_nested_where_with_relation
-      author = authors(:david)
-
-      expected = Author.where(id: author ).joins(:posts)
-      actual   = Author.where(posts: { author_id: Author.where(id: author.id) }).joins(:posts)
-
-      assert_equal expected.to_a, actual.to_a
-    end
-
-    def test_polymorphic_shallow_where
-      treasure = Treasure.new
-      treasure.id = 1
-
-      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: 1)
-      actual   = PriceEstimate.where(estimate_of: treasure)
-
-      assert_equal expected.to_sql, actual.to_sql
-    end
-
-    def test_polymorphic_nested_array_where
-      treasure = Treasure.new
-      treasure.id = 1
-      hidden = HiddenTreasure.new
-      hidden.id = 2
-
-      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: [treasure, hidden])
-      actual   = PriceEstimate.where(estimate_of: [treasure, hidden])
-
-      assert_equal expected.to_sql, actual.to_sql
-    end
-
-    def test_polymorphic_array_where_multiple_types
-      treasure_1 = treasures(:diamond)
-      treasure_2 = treasures(:sapphire)
-      car = cars(:honda)
-
-      expected = [price_estimates(:diamond), price_estimates(:sapphire_1), price_estimates(:sapphire_2), price_estimates(:honda)].sort
-      actual   = PriceEstimate.where(estimate_of: [treasure_1, treasure_2, car]).to_a.sort
-
-      assert_equal expected, actual
-    end
-
-    def test_polymorphic_nested_relation_where
-      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: Treasure.where(id: [1,2]))
-      actual   = PriceEstimate.where(estimate_of: Treasure.where(id: [1,2]))
-
-      assert_equal expected.to_sql, actual.to_sql
-    end
-
-    def test_polymorphic_sti_shallow_where
-      treasure = HiddenTreasure.new
-      treasure.id = 1
-
-      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: 1)
-      actual   = PriceEstimate.where(estimate_of: treasure)
-
-      assert_equal expected.to_sql, actual.to_sql
-    end
-
-    def test_polymorphic_nested_where
-      thing = Post.new
-      thing.id = 1
-
-      expected = Treasure.where(price_estimates: { thing_type: 'Post', thing_id: 1 }).joins(:price_estimates)
-      actual   = Treasure.where(price_estimates: { thing: thing }).joins(:price_estimates)
-
-      assert_equal expected.to_sql, actual.to_sql
-    end
-
-    def test_polymorphic_sti_nested_where
-      treasure = HiddenTreasure.new
-      treasure.id = 1
-
-      expected = Treasure.where(price_estimates: { estimate_of_type: 'Treasure', estimate_of_id: 1 }).joins(:price_estimates)
-      actual   = Treasure.where(price_estimates: { estimate_of: treasure }).joins(:price_estimates)
-
-      assert_equal expected.to_sql, actual.to_sql
-    end
-
-    def test_decorated_polymorphic_where
-      treasure_decorator = Struct.new(:model) do
-        def self.method_missing(method, *args, &block)
-          Treasure.send(method, *args, &block)
-        end
-
-        def is_a?(klass)
-          model.is_a?(klass)
-        end
-
-        def method_missing(method, *args, &block)
-          model.send(method, *args, &block)
-        end
-      end
-
-      treasure = Treasure.new
-      treasure.id = 1
-      decorated_treasure = treasure_decorator.new(treasure)
-
-      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: 1)
-      actual   = PriceEstimate.where(estimate_of: decorated_treasure)
-
-      assert_equal expected.to_sql, actual.to_sql
-    end
-
-    def test_aliased_attribute
-      expected = Topic.where(heading: 'The First Topic')
-      actual   = Topic.where(title: 'The First Topic')
-
-      assert_equal expected.to_sql, actual.to_sql
-    end
-
-    def test_where_error
-      assert_raises(ActiveRecord::StatementInvalid) do
-        Post.where(:id => { 'posts.author_id' => 10 }).first
-      end
-    end
-
-    def test_where_with_table_name
-      post = Post.first
-      assert_equal post, Post.where(:posts => { 'id' => post.id }).first
-    end
-
-    def test_where_with_table_name_and_empty_hash
-      assert_equal 0, Post.where(:posts => {}).count
-    end
-
-    def test_where_with_table_name_and_empty_array
-      assert_equal 0, Post.where(:id => []).count
-    end
-
-    def test_where_with_empty_hash_and_no_foreign_key
-      assert_equal 0, Edge.where(:sink => {}).count
-    end
-
-    def test_where_with_blank_conditions
-      [[], {}, nil, ""].each do |blank|
-        assert_equal 4, Edge.where(blank).order("sink_id").to_a.size
-      end
-    end
-
-    def test_where_with_integer_for_string_column
-      count = Post.where(:title => 0).count
-      assert_equal 0, count
-    end
-
-    def test_where_with_float_for_string_column
-      count = Post.where(:title => 0.0).count
-      assert_equal 0, count
-    end
-
-    def test_where_with_boolean_for_string_column
-      count = Post.where(:title => false).count
-      assert_equal 0, count
-    end
-
-    def test_where_with_decimal_for_string_column
-      count = Post.where(:title => BigDecimal.new(0)).count
-      assert_equal 0, count
-    end
-
-    def test_where_with_duration_for_string_column
-      count = Post.where(:title => 0.seconds).count
-      assert_equal 0, count
-    end
-
-    def test_where_with_integer_for_binary_column
-      count = Binary.where(:data => 0).count
-      assert_equal 0, count
-    end
-
-    def test_where_on_association_with_custom_primary_key
-      author = authors(:david)
-      essay = Essay.where(writer: author).first
-
-      assert_equal essays(:david_modest_proposal), essay
-    end
-
-    def test_where_on_association_with_custom_primary_key_with_relation
-      author = authors(:david)
-      essay = Essay.where(writer: Author.where(id: author.id)).first
-
-      assert_equal essays(:david_modest_proposal), essay
-    end
-
-    def test_where_on_association_with_relation_performs_subselect_not_two_queries
-      author = authors(:david)
-
-      assert_queries(1) do
-        Essay.where(writer: Author.where(id: author.id)).to_a
-      end
-    end
-
-    def test_where_on_association_with_custom_primary_key_with_array_of_base
-      author = authors(:david)
-      essay = Essay.where(writer: [author]).first
-
-      assert_equal essays(:david_modest_proposal), essay
-    end
-
-    def test_where_on_association_with_custom_primary_key_with_array_of_ids
-      essay = Essay.where(writer: ["David"]).first
-
-      assert_equal essays(:david_modest_proposal), essay
-    end
-
-    def test_where_with_strong_parameters
-      protected_params = Class.new do
-        attr_reader :permitted
-        alias :permitted? :permitted
-
-        def initialize(parameters)
-          @parameters = parameters
-          @permitted = false
-        end
-
-        def to_h
-          @parameters
-        end
-
-        def permit!
-          @permitted = true
-          self
-        end
-      end
-
-      author = authors(:david)
-      params = protected_params.new(name: author.name)
-      assert_raises(ActiveModel::ForbiddenAttributesError) { Author.where(params) }
-      assert_equal author, Author.where(params.permit!).first
-    end
-
-    def test_where_with_unsupported_arguments
-      assert_raises(ArgumentError) { Author.where(42) }
-    end
-  end
-end
+require "cases/helper"
+require "models/author"
+require "models/binary"
+require "models/cake_designer"
+require "models/car"
+require "models/chef"
+require "models/comment"
+require "models/edge"
+require "models/essay"
+require "models/post"
+require "models/price_estimate"
+require "models/topic"
+require "models/treasure"
+require "models/vertex"
+
+module ActiveRecord
+  class WhereTest < ActiveRecord::TestCase
+    fixtures :posts, :edges, :authors, :binaries, :essays, :cars, :treasures, :price_estimates
+
+    def test_where_copies_bind_params
+      author = authors(:david)
+      posts  = author.posts.where('posts.id != 1')
+      joined = Post.where(id: posts)
+
+      assert_operator joined.length, :>, 0
+
+      joined.each { |post|
+        assert_equal author, post.author
+        assert_not_equal 1, post.id
+      }
+    end
+
+    def test_where_copies_bind_params_in_the_right_order
+      author = authors(:david)
+      posts = author.posts.where.not(id: 1)
+      joined = Post.where(id: posts, title: posts.first.title)
+
+      assert_equal joined, [posts.first]
+    end
+
+    def test_where_copies_arel_bind_params
+      chef = Chef.create!
+      CakeDesigner.create!(chef: chef)
+
+      cake_designers = CakeDesigner.joins(:chef).where(chefs: { id: chef.id })
+      chefs = Chef.where(employable: cake_designers)
+
+      assert_equal [chef], chefs.to_a
+    end
+
+    def test_rewhere_on_root
+      assert_equal posts(:welcome), Post.rewhere(title: 'Welcome to the weblog').first
+    end
+
+    def test_belongs_to_shallow_where
+      author = Author.new
+      author.id = 1
+
+      assert_equal Post.where(author_id: 1).to_sql, Post.where(author: author).to_sql
+    end
+
+    def test_belongs_to_nil_where
+      assert_equal Post.where(author_id: nil).to_sql, Post.where(author: nil).to_sql
+    end
+
+    def test_belongs_to_array_value_where
+      assert_equal Post.where(author_id: [1,2]).to_sql, Post.where(author: [1,2]).to_sql
+    end
+
+    def test_belongs_to_nested_relation_where
+      expected = Post.where(author_id: Author.where(id: [1,2])).to_sql
+      actual   = Post.where(author:    Author.where(id: [1,2])).to_sql
+
+      assert_equal expected, actual
+    end
+
+    def test_belongs_to_nested_where
+      parent = Comment.new
+      parent.id = 1
+
+      expected = Post.where(comments: { parent_id: 1 }).joins(:comments)
+      actual   = Post.where(comments: { parent: parent }).joins(:comments)
+
+      assert_equal expected.to_sql, actual.to_sql
+    end
+
+    def test_belongs_to_nested_where_with_relation
+      author = authors(:david)
+
+      expected = Author.where(id: author ).joins(:posts)
+      actual   = Author.where(posts: { author_id: Author.where(id: author.id) }).joins(:posts)
+
+      assert_equal expected.to_a, actual.to_a
+    end
+
+    def test_polymorphic_shallow_where
+      treasure = Treasure.new
+      treasure.id = 1
+
+      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: 1)
+      actual   = PriceEstimate.where(estimate_of: treasure)
+
+      assert_equal expected.to_sql, actual.to_sql
+    end
+
+    def test_polymorphic_nested_array_where
+      treasure = Treasure.new
+      treasure.id = 1
+      hidden = HiddenTreasure.new
+      hidden.id = 2
+
+      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: [treasure, hidden])
+      actual   = PriceEstimate.where(estimate_of: [treasure, hidden])
+
+      assert_equal expected.to_sql, actual.to_sql
+    end
+
+    def test_polymorphic_array_where_multiple_types
+      treasure_1 = treasures(:diamond)
+      treasure_2 = treasures(:sapphire)
+      car = cars(:honda)
+
+      expected = [price_estimates(:diamond), price_estimates(:sapphire_1), price_estimates(:sapphire_2), price_estimates(:honda)].sort
+      actual   = PriceEstimate.where(estimate_of: [treasure_1, treasure_2, car]).to_a.sort
+
+      assert_equal expected, actual
+    end
+
+    def test_polymorphic_nested_relation_where
+      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: Treasure.where(id: [1,2]))
+      actual   = PriceEstimate.where(estimate_of: Treasure.where(id: [1,2]))
+
+      assert_equal expected.to_sql, actual.to_sql
+    end
+
+    def test_polymorphic_sti_shallow_where
+      treasure = HiddenTreasure.new
+      treasure.id = 1
+
+      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: 1)
+      actual   = PriceEstimate.where(estimate_of: treasure)
+
+      assert_equal expected.to_sql, actual.to_sql
+    end
+
+    def test_polymorphic_nested_where
+      thing = Post.new
+      thing.id = 1
+
+      expected = Treasure.where(price_estimates: { thing_type: 'Post', thing_id: 1 }).joins(:price_estimates)
+      actual   = Treasure.where(price_estimates: { thing: thing }).joins(:price_estimates)
+
+      assert_equal expected.to_sql, actual.to_sql
+    end
+
+    def test_polymorphic_sti_nested_where
+      treasure = HiddenTreasure.new
+      treasure.id = 1
+
+      expected = Treasure.where(price_estimates: { estimate_of_type: 'Treasure', estimate_of_id: 1 }).joins(:price_estimates)
+      actual   = Treasure.where(price_estimates: { estimate_of: treasure }).joins(:price_estimates)
+
+      assert_equal expected.to_sql, actual.to_sql
+    end
+
+    def test_decorated_polymorphic_where
+      treasure_decorator = Struct.new(:model) do
+        def self.method_missing(method, *args, &block)
+          Treasure.send(method, *args, &block)
+        end
+
+        def is_a?(klass)
+          model.is_a?(klass)
+        end
+
+        def method_missing(method, *args, &block)
+          model.send(method, *args, &block)
+        end
+      end
+
+      treasure = Treasure.new
+      treasure.id = 1
+      decorated_treasure = treasure_decorator.new(treasure)
+
+      expected = PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: 1)
+      actual   = PriceEstimate.where(estimate_of: decorated_treasure)
+
+      assert_equal expected.to_sql, actual.to_sql
+    end
+
+    def test_aliased_attribute
+      expected = Topic.where(heading: 'The First Topic')
+      actual   = Topic.where(title: 'The First Topic')
+
+      assert_equal expected.to_sql, actual.to_sql
+    end
+
+    def test_where_error
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Post.where(:id => { 'posts.author_id' => 10 }).first
+      end
+    end
+
+    def test_where_with_table_name
+      post = Post.first
+      assert_equal post, Post.where(:posts => { 'id' => post.id }).first
+    end
+
+    def test_where_with_table_name_and_empty_hash
+      assert_equal 0, Post.where(:posts => {}).count
+    end
+
+    def test_where_with_table_name_and_empty_array
+      assert_equal 0, Post.where(:id => []).count
+    end
+
+    def test_where_with_empty_hash_and_no_foreign_key
+      assert_equal 0, Edge.where(:sink => {}).count
+    end
+
+    def test_where_with_blank_conditions
+      [[], {}, nil, ""].each do |blank|
+        assert_equal 4, Edge.where(blank).order("sink_id").to_a.size
+      end
+    end
+
+    def test_where_with_integer_for_string_column
+      count = Post.where(:title => 0).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_float_for_string_column
+      count = Post.where(:title => 0.0).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_boolean_for_string_column
+      count = Post.where(:title => false).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_decimal_for_string_column
+      count = Post.where(:title => BigDecimal.new(0)).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_duration_for_string_column
+      count = Post.where(:title => 0.seconds).count
+      assert_equal 0, count
+    end
+
+    def test_where_with_integer_for_binary_column
+      count = Binary.where(:data => 0).count
+      assert_equal 0, count
+    end
+
+    def test_where_on_association_with_custom_primary_key
+      author = authors(:david)
+      essay = Essay.where(writer: author).first
+
+      assert_equal essays(:david_modest_proposal), essay
+    end
+
+    def test_where_on_association_with_custom_primary_key_with_relation
+      author = authors(:david)
+      essay = Essay.where(writer: Author.where(id: author.id)).first
+
+      assert_equal essays(:david_modest_proposal), essay
+    end
+
+    def test_where_on_association_with_relation_performs_subselect_not_two_queries
+      author = authors(:david)
+
+      assert_queries(1) do
+        Essay.where(writer: Author.where(id: author.id)).to_a
+      end
+    end
+
+    def test_where_on_association_with_custom_primary_key_with_array_of_base
+      author = authors(:david)
+      essay = Essay.where(writer: [author]).first
+
+      assert_equal essays(:david_modest_proposal), essay
+    end
+
+    def test_where_on_association_with_custom_primary_key_with_array_of_ids
+      essay = Essay.where(writer: ["David"]).first
+
+      assert_equal essays(:david_modest_proposal), essay
+    end
+
+    def test_where_with_strong_parameters
+      protected_params = Class.new do
+        attr_reader :permitted
+        alias :permitted? :permitted
+
+        def initialize(parameters)
+          @parameters = parameters
+          @permitted = false
+        end
+
+        def to_h
+          @parameters
+        end
+
+        def permit!
+          @permitted = true
+          self
+        end
+      end
+
+      author = authors(:david)
+      params = protected_params.new(name: author.name)
+      assert_raises(ActiveModel::ForbiddenAttributesError) { Author.where(params) }
+      assert_equal author, Author.where(params.permit!).first
+    end
+
+    def test_where_with_unsupported_arguments
+      assert_raises(ArgumentError) { Author.where(42) }
+    end
+  end
+end