ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

data/test/cases/relation/update_all_test.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/category"
+require "models/comment"
+require "models/computer"
+require "models/developer"
+require "models/post"
+require "models/person"
+require "models/pet"
+require "models/toy"
+require "models/topic"
+require "models/tag"
+require "models/tagging"
+require "models/warehouse_thing"
+
+class UpdateAllTest < ActiveRecord::TestCase
+  fixtures :authors, :author_addresses, :comments, :developers, :posts, :people, :pets, :toys, :tags, :taggings, "warehouse_things"
+
+  class TopicWithCallbacks < ActiveRecord::Base
+    self.table_name = :topics
+    cattr_accessor :topic_count
+    before_update { |topic| topic.author_name = "David" if topic.author_name.blank? }
+    after_update { |topic| topic.class.topic_count = topic.class.count }
+  end
+
+  def test_update_all_with_scope
+    tag = Tag.first
+    Post.tagged_with(tag.id).update_all(title: "rofl")
+    posts = Post.tagged_with(tag.id).all.to_a
+    assert_operator posts.length, :>, 0
+    posts.each { |post| assert_equal "rofl", post.title }
+  end
+
+  def test_update_all_with_non_standard_table_name
+    assert_equal 1, WarehouseThing.where(id: 1).update_all(["value = ?", 0])
+    assert_equal 0, WarehouseThing.find(1).value
+  end
+
+  def test_update_all_with_blank_argument
+    assert_raises(ArgumentError) { Comment.update_all({}) }
+  end
+
+  def test_update_all_with_joins
+    pets = Pet.joins(:toys).where(toys: { name: "Bone" })
+
+    assert_equal true, pets.exists?
+    sqls = capture_sql do
+      assert_equal pets.count, pets.update_all(name: "Bob")
+    end
+
+    if current_adapter?(:Mysql2Adapter)
+      assert_no_match %r/SELECT DISTINCT #{Regexp.escape(Pet.connection.quote_table_name("pets.pet_id"))}/, sqls.last
+    else
+      assert_match %r/SELECT #{Regexp.escape(Pet.connection.quote_table_name("pets.pet_id"))}/, sqls.last
+    end
+  end
+
+  def test_update_all_with_left_joins
+    pets = Pet.left_joins(:toys).where(toys: { name: "Bone" })
+
+    assert_equal true, pets.exists?
+    assert_equal pets.count, pets.update_all(name: "Bob")
+  end
+
+  def test_update_all_with_includes
+    pets = Pet.includes(:toys).where(toys: { name: "Bone" })
+
+    assert_equal true, pets.exists?
+    assert_equal pets.count, pets.update_all(name: "Bob")
+  end
+
+  def test_update_all_with_joins_and_limit_and_order
+    comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).order("comments.id").limit(1)
+    assert_equal 1, comments.count
+    assert_equal 1, comments.update_all(post_id: posts(:thinking).id)
+    assert_equal posts(:thinking), comments(:greetings).post
+    assert_equal posts(:welcome),  comments(:more_greetings).post
+  end
+
+  def test_update_all_with_joins_and_offset_and_order
+    comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).order("comments.id").offset(1)
+    assert_equal 1, comments.count
+    assert_equal 1, comments.update_all(post_id: posts(:thinking).id)
+    assert_equal posts(:thinking), comments(:more_greetings).post
+    assert_equal posts(:welcome),  comments(:greetings).post
+  end
+
+  def test_update_counters_with_joins
+    assert_nil pets(:parrot).integer
+
+    Pet.joins(:toys).where(toys: { name: "Bone" }).update_counters(integer: 1)
+
+    assert_equal 1, pets(:parrot).reload.integer
+  end
+
+  def test_touch_all_updates_records_timestamps
+    david = developers(:david)
+    david_previously_updated_at = david.updated_at
+    jamis = developers(:jamis)
+    jamis_previously_updated_at = jamis.updated_at
+    Developer.where(name: "David").touch_all
+
+    assert_not_equal david_previously_updated_at, david.reload.updated_at
+    assert_equal jamis_previously_updated_at, jamis.reload.updated_at
+  end
+
+  def test_touch_all_with_custom_timestamp
+    developer = developers(:david)
+    previously_created_at = developer.created_at
+    previously_updated_at = developer.updated_at
+    Developer.where(name: "David").touch_all(:created_at)
+    developer.reload
+
+    assert_not_equal previously_created_at, developer.created_at
+    assert_not_equal previously_updated_at, developer.updated_at
+  end
+
+  def test_touch_all_with_given_time
+    developer = developers(:david)
+    previously_created_at = developer.created_at
+    previously_updated_at = developer.updated_at
+    new_time = Time.utc(2015, 2, 16, 4, 54, 0)
+    Developer.where(name: "David").touch_all(:created_at, time: new_time)
+    developer.reload
+
+    assert_not_equal previously_created_at, developer.created_at
+    assert_not_equal previously_updated_at, developer.updated_at
+    assert_equal new_time, developer.created_at
+    assert_equal new_time, developer.updated_at
+  end
+
+  def test_update_on_relation
+    topic1 = TopicWithCallbacks.create! title: "arel", author_name: nil
+    topic2 = TopicWithCallbacks.create! title: "activerecord", author_name: nil
+    topics = TopicWithCallbacks.where(id: [topic1.id, topic2.id])
+    topics.update(title: "adequaterecord")
+
+    assert_equal TopicWithCallbacks.count, TopicWithCallbacks.topic_count
+
+    assert_equal "adequaterecord", topic1.reload.title
+    assert_equal "adequaterecord", topic2.reload.title
+    # Testing that the before_update callbacks have run
+    assert_equal "David", topic1.reload.author_name
+    assert_equal "David", topic2.reload.author_name
+  end
+
+  def test_update_with_ids_on_relation
+    topic1 = TopicWithCallbacks.create!(title: "arel", author_name: nil)
+    topic2 = TopicWithCallbacks.create!(title: "activerecord", author_name: nil)
+    topics = TopicWithCallbacks.none
+    topics.update(
+      [topic1.id, topic2.id],
+      [{ title: "adequaterecord" }, { title: "adequaterecord" }]
+    )
+
+    assert_equal TopicWithCallbacks.count, TopicWithCallbacks.topic_count
+
+    assert_equal "adequaterecord", topic1.reload.title
+    assert_equal "adequaterecord", topic2.reload.title
+    # Testing that the before_update callbacks have run
+    assert_equal "David", topic1.reload.author_name
+    assert_equal "David", topic2.reload.author_name
+  end
+
+  def test_update_on_relation_passing_active_record_object_is_not_permitted
+    topic = Topic.create!(title: "Foo", author_name: nil)
+    assert_raises(ArgumentError) do
+      Topic.where(id: topic.id).update(topic, title: "Bar")
+    end
+  end
+
+  def test_update_all_cares_about_optimistic_locking
+    david = people(:david)
+
+    travel 5.seconds do
+      now = Time.now.utc
+      assert_not_equal now, david.updated_at
+
+      people = Person.where(id: people(:michael, :david, :susan))
+      expected = people.pluck(:lock_version)
+      expected.map! { |version| version + 1 }
+      people.update_all(updated_at: now)
+
+      assert_equal [now] * 3, people.pluck(:updated_at)
+      assert_equal expected, people.pluck(:lock_version)
+
+      assert_raises(ActiveRecord::StaleObjectError) do
+        david.touch(time: now)
+      end
+    end
+  end
+
+  def test_update_counters_cares_about_optimistic_locking
+    david = people(:david)
+
+    travel 5.seconds do
+      now = Time.now.utc
+      assert_not_equal now, david.updated_at
+
+      people = Person.where(id: people(:michael, :david, :susan))
+      expected = people.pluck(:lock_version)
+      expected.map! { |version| version + 1 }
+      people.update_counters(touch: { time: now })
+
+      assert_equal [now] * 3, people.pluck(:updated_at)
+      assert_equal expected, people.pluck(:lock_version)
+
+      assert_raises(ActiveRecord::StaleObjectError) do
+        david.touch(time: now)
+      end
+    end
+  end
+
+  def test_touch_all_cares_about_optimistic_locking
+    david = people(:david)
+
+    travel 5.seconds do
+      now = Time.now.utc
+      assert_not_equal now, david.updated_at
+
+      people = Person.where(id: people(:michael, :david, :susan))
+      expected = people.pluck(:lock_version)
+      expected.map! { |version| version + 1 }
+      people.touch_all(time: now)
+
+      assert_equal [now] * 3, people.pluck(:updated_at)
+      assert_equal expected, people.pluck(:lock_version)
+
+      assert_raises(ActiveRecord::StaleObjectError) do
+        david.touch(time: now)
+      end
+    end
+  end
+
+  def test_klass_level_update_all
+    travel 5.seconds do
+      now = Time.now.utc
+
+      Person.all.each do |person|
+        assert_not_equal now, person.updated_at
+      end
+
+      Person.update_all(updated_at: now)
+
+      Person.all.each do |person|
+        assert_equal now, person.updated_at
+      end
+    end
+  end
+
+  def test_klass_level_touch_all
+    travel 5.seconds do
+      now = Time.now.utc
+
+      Person.all.each do |person|
+        assert_not_equal now, person.updated_at
+      end
+
+      Person.touch_all(time: now)
+
+      Person.all.each do |person|
+        assert_equal now, person.updated_at
+      end
+    end
+  end
+
+  # Oracle UPDATE does not support ORDER BY
+  unless current_adapter?(:OracleAdapter)
+    def test_update_all_ignores_order_without_limit_from_association
+      author = authors(:david)
+      assert_nothing_raised do
+        assert_equal author.posts_with_comments_and_categories.length, author.posts_with_comments_and_categories.update_all([ "body = ?", "bulk update!" ])
+      end
+    end
+
+    def test_update_all_doesnt_ignore_order
+      assert_equal authors(:david).id + 1, authors(:mary).id # make sure there is going to be a duplicate PK error
+      test_update_with_order_succeeds = lambda do |order|
+        Author.order(order).update_all("id = id + 1")
+      rescue ActiveRecord::ActiveRecordError
+        false
+      end
+
+      if test_update_with_order_succeeds.call("id DESC")
+        # test that this wasn't a fluke and using an incorrect order results in an exception
+        assert_not test_update_with_order_succeeds.call("id ASC")
+      else
+        # test that we're failing because the current Arel's engine doesn't support UPDATE ORDER BY queries is using subselects instead
+        assert_sql(/\AUPDATE .+ \(SELECT .* ORDER BY id DESC\)\z/i) do
+          test_update_with_order_succeeds.call("id DESC")
+        end
+      end
+    end
+
+    def test_update_all_with_order_and_limit_updates_subset_only
+      author = authors(:david)
+      limited_posts = author.posts_sorted_by_id_limited
+      assert_equal 1, limited_posts.size
+      assert_equal 2, limited_posts.limit(2).size
+      assert_equal 1, limited_posts.update_all([ "body = ?", "bulk update!" ])
+      assert_equal "bulk update!", posts(:welcome).body
+      assert_not_equal "bulk update!", posts(:thinking).body
+    end
+
+    def test_update_all_with_order_and_limit_and_offset_updates_subset_only
+      author = authors(:david)
+      limited_posts = author.posts_sorted_by_id_limited.offset(1)
+      assert_equal 1, limited_posts.size
+      assert_equal 2, limited_posts.limit(2).size
+      assert_equal 1, limited_posts.update_all([ "body = ?", "bulk update!" ])
+      assert_equal "bulk update!", posts(:thinking).body
+      assert_not_equal "bulk update!", posts(:welcome).body
+    end
+  end
+end

data/test/cases/relation/where_chain_test.rb

@@ -1,19 +1,30 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/comment'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/author"
+require "models/human"
+require "models/essay"
+require "models/comment"
+require "models/categorization"
 
 module ActiveRecord
   class WhereChainTest < ActiveRecord::TestCase
-    fixtures :posts
+    fixtures :posts, :comments, :authors, :humans, :essays, :author_addresses
+
+    def test_missing_with_association
+      assert posts(:authorless).author.blank?
+      assert_equal [posts(:authorless)], Post.where.missing(:author).to_a
+    end
 
-    def setup
-      super
-      @name = 'title'
+    def test_missing_with_multiple_association
+      assert posts(:authorless).comments.empty?
+      assert_equal [posts(:authorless)], Post.where.missing(:author, :comments).to_a
     end
 
     def test_not_inverts_where_clause
-      relation = Post.where.not(title: 'hello')
-      expected_where_clause = Post.where(title: 'hello').where_clause.invert
+      relation = Post.where.not(title: "hello")
+      expected_where_clause = Post.where(title: "hello").where_clause.invert
 
       assert_equal expected_where_clause, relation.where_clause
     end
@@ -25,81 +36,106 @@ module ActiveRecord
     end
 
     def test_association_not_eq
-      expected = Arel::Nodes::Grouping.new(Comment.arel_table[@name].not_eq(Arel::Nodes::BindParam.new))
-      relation = Post.joins(:comments).where.not(comments: {title: 'hello'})
+      expected = Comment.arel_table["title"].not_eq(Arel::Nodes::BindParam.new(1))
+      relation = Post.joins(:comments).where.not(comments: { title: "hello" })
       assert_equal(expected.to_sql, relation.where_clause.ast.to_sql)
     end
 
     def test_not_eq_with_preceding_where
-      relation = Post.where(title: 'hello').where.not(title: 'world')
+      relation = Post.where(title: "hello").where.not(title: "world")
       expected_where_clause =
-        Post.where(title: 'hello').where_clause +
-        Post.where(title: 'world').where_clause.invert
+        Post.where(title: "hello").where_clause +
+        Post.where(title: "world").where_clause.invert
 
       assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_not_eq_with_succeeding_where
-      relation = Post.where.not(title: 'hello').where(title: 'world')
+      relation = Post.where.not(title: "hello").where(title: "world")
       expected_where_clause =
-        Post.where(title: 'hello').where_clause.invert +
-        Post.where(title: 'world').where_clause
+        Post.where(title: "hello").where_clause.invert +
+        Post.where(title: "world").where_clause
 
       assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_chaining_multiple
-      relation = Post.where.not(author_id: [1, 2]).where.not(title: 'ruby on rails')
+      relation = Post.where.not(author_id: [1, 2]).where.not(title: "ruby on rails")
       expected_where_clause =
         Post.where(author_id: [1, 2]).where_clause.invert +
-        Post.where(title: 'ruby on rails').where_clause.invert
+        Post.where(title: "ruby on rails").where_clause.invert
 
       assert_equal expected_where_clause, relation.where_clause
     end
 
     def test_rewhere_with_one_condition
-      relation = Post.where(title: 'hello').where(title: 'world').rewhere(title: 'alone')
-      expected = Post.where(title: 'alone')
+      relation = Post.where(body: "hello").where(body: "world").rewhere(body: "hullo")
+      expected = Post.where(body: "hullo")
 
-      assert_equal expected.where_clause, relation.where_clause
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_multiple_overwriting_conditions
-      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone', body: 'again')
-      expected = Post.where(title: 'alone', body: 'again')
+      relation = Post.where(body: "hello").where(type: "StiPost").rewhere(body: "hullo", type: "Post")
+      expected = Post.where(body: "hullo", type: "Post")
 
-      assert_equal expected.where_clause, relation.where_clause
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_one_overwriting_condition_and_one_unrelated
-      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone')
-      expected = Post.where(body: 'world', title: 'alone')
+      relation = Post.where(body: "hello").where(type: "Post").rewhere(body: "hullo")
+      expected = Post.where(body: "hullo", type: "Post")
+
+      assert_equal expected.to_a, relation.to_a
+    end
+
+    def test_rewhere_with_alias_condition
+      relation = Post.where(text: "hello").where(text: "world").rewhere(text: "hullo")
+      expected = Post.where(text: "hullo")
+
+      assert_equal expected.to_a, relation.to_a
+    end
+
+    def test_rewhere_with_nested_condition
+      relation = Post.where.missing(:comments).rewhere("comments.id": comments(:does_it_hurt))
+      expected = Post.left_joins(:comments).where("comments.id": comments(:does_it_hurt))
+
+      assert_equal expected.to_a, relation.to_a
+    end
+
+    def test_rewhere_with_polymorphic_association
+      relation = Essay.where(writer: authors(:david)).rewhere(writer: humans(:steve))
+      expected = Essay.where(writer: humans(:steve))
 
-      assert_equal expected.where_clause, relation.where_clause
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_range
       relation = Post.where(comments_count: 1..3).rewhere(comments_count: 3..5)
+      expected = Post.where(comments_count: 3..5)
 
-      assert_equal Post.where(comments_count: 3..5), relation
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_infinite_upper_bound_range
       relation = Post.where(comments_count: 1..Float::INFINITY).rewhere(comments_count: 3..5)
+      expected = Post.where(comments_count: 3..5)
 
-      assert_equal Post.where(comments_count: 3..5), relation
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_infinite_lower_bound_range
       relation = Post.where(comments_count: -Float::INFINITY..1).rewhere(comments_count: 3..5)
+      expected = Post.where(comments_count: 3..5)
 
-      assert_equal Post.where(comments_count: 3..5), relation
+      assert_equal expected.to_a, relation.to_a
     end
 
     def test_rewhere_with_infinite_range
       relation = Post.where(comments_count: -Float::INFINITY..Float::INFINITY).rewhere(comments_count: 3..5)
+      expected = Post.where(comments_count: 3..5)
 
-      assert_equal Post.where(comments_count: 3..5), relation
+      assert_equal expected.to_a, relation.to_a
     end
   end
 end