ibm_db 5.2.0 → 5.3.2

data/test/cases/associations/bidirectional_destroy_dependencies_test.rb

@@ -1,5 +1,7 @@
-require 'cases/helper'
-require 'models/content'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/content"
 
 class BidirectionalDestroyDependenciesTest < ActiveRecord::TestCase
   fixtures :content, :content_positions

data/test/cases/associations/callbacks_test.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/post'
-require 'models/author'
-require 'models/project'
-require 'models/developer'
-require 'models/computer'
-require 'models/company'
+require "models/post"
+require "models/author"
+require "models/project"
+require "models/developer"
+require "models/computer"
+require "models/company"
 
 class AssociationCallbacksTest < ActiveRecord::TestCase
-  fixtures :posts, :authors, :projects, :developers
+  fixtures :posts, :authors, :author_addresses, :projects, :developers
 
   def setup
     @david = authors(:david)
     @thinking = posts(:thinking)
     @authorless = posts(:authorless)
-    assert @david.post_log.empty?
+    assert_empty @david.post_log
   end
 
   def test_adding_macro_callbacks
@@ -60,21 +62,38 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
                   "after_adding#{@thinking.id}", "after_adding_proc#{@thinking.id}"], @david.post_log
   end
 
+  def test_has_many_callbacks_halt_execution_when_abort_is_trown_when_adding_to_association
+    author = Author.create!(name: "Roger")
+    post = Post.create!(title: "hello", body: "abc")
+    author.posts_with_thrown_callbacks << post
+
+    assert_empty(author.posts_with_callbacks)
+  end
+
+  def test_has_many_callbacks_halt_execution_when_abort_is_trown_when_removing_from_association
+    author = Author.create!(name: "Roger")
+    post = Post.create!(title: "hello", body: "abc", author: author)
+
+    assert_equal(1, author.posts_with_thrown_callbacks.size)
+    author.posts_with_thrown_callbacks.destroy(post.id)
+    assert_equal(1, author.posts_with_thrown_callbacks.size)
+  end
+
   def test_has_many_callbacks_with_create
-    morten = Author.create :name => "Morten"
-    post = morten.posts_with_proc_callbacks.create! :title => "Hello", :body => "How are you doing?"
+    morten = Author.create name: "Morten"
+    post = morten.posts_with_proc_callbacks.create! title: "Hello", body: "How are you doing?"
     assert_equal ["before_adding<new>", "after_adding#{post.id}"], morten.post_log
   end
 
   def test_has_many_callbacks_with_create!
-    morten = Author.create! :name => "Morten"
-    post = morten.posts_with_proc_callbacks.create :title => "Hello", :body => "How are you doing?"
+    morten = Author.create! name: "Morten"
+    post = morten.posts_with_proc_callbacks.create title: "Hello", body: "How are you doing?"
     assert_equal ["before_adding<new>", "after_adding#{post.id}"], morten.post_log
   end
 
   def test_has_many_callbacks_for_save_on_parent
-    jack = Author.new :name => "Jack"
-    jack.posts_with_callbacks.build :title => "Call me back!", :body => "Before you wake up and after you sleep"
+    jack = Author.new name: "Jack"
+    jack.posts_with_callbacks.build title: "Call me back!", body: "Before you wake up and after you sleep"
 
     callback_log = ["before_adding<new>", "after_adding#{jack.posts_with_callbacks.first.id}"]
     assert_equal callback_log, jack.post_log
@@ -84,8 +103,8 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
   end
 
   def test_has_many_callbacks_for_destroy_on_parent
-    firm = Firm.create! :name => "Firm"
-    client = firm.clients.create! :name => "Client"
+    firm = Firm.create! name: "Firm"
+    client = firm.clients.create! name: "Client"
     firm.destroy
 
     assert_equal ["before_remove#{client.id}", "after_remove#{client.id}"], firm.log
@@ -94,7 +113,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
   def test_has_and_belongs_to_many_add_callback
     david = developers(:david)
     ar = projects(:active_record)
-    assert ar.developers_log.empty?
+    assert_empty ar.developers_log
     ar.developers_with_callbacks << david
     assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], ar.developers_log
     ar.developers_with_callbacks << david
@@ -108,41 +127,40 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     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|
+                                class_name: "Developer",
+                                before_add: lambda { |o, r|
         dev     = r
         new_dev = r.new_record?
       }
     end
     rec = klass.create!
-    alice = Developer.new(:name => 'alice')
+    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?
+    assert_not_predicate 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?
-    alice = Developer.new(:name => 'alice')
+    assert_empty ar.developers_log
+    alice = Developer.new(name: "alice")
     ar.developers_with_callbacks << alice
-    assert_equal"after_adding#{alice.id}", ar.developers_log.last
+    assert_equal "after_adding#{alice.id}", ar.developers_log.last
 
-    bob = ar.developers_with_callbacks.create(:name => 'bob')
+    bob = ar.developers_with_callbacks.create(name: "bob")
     assert_equal "after_adding#{bob.id}", ar.developers_log.last
 
-    ar.developers_with_callbacks.build(:name => 'charlie')
+    ar.developers_with_callbacks.build(name: "charlie")
     assert_equal "after_adding<new>", ar.developers_log.last
   end
 
-
   def test_has_and_belongs_to_many_remove_callback
     david = developers(:david)
     jamis = developers(:jamis)
     activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
+    assert_empty activerecord.developers_log
     activerecord.developers_with_callbacks.delete(david)
     assert_equal ["before_removing#{david.id}", "after_removing#{david.id}"], activerecord.developers_log
 
@@ -153,21 +171,21 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
 
   def test_has_and_belongs_to_many_does_not_fire_callbacks_on_clear
     activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
+    assert_empty activerecord.developers_log
     if activerecord.developers_with_callbacks.size == 0
       activerecord.developers << developers(:david)
       activerecord.developers << developers(:jamis)
       activerecord.reload
       assert activerecord.developers_with_callbacks.size == 2
     end
-    activerecord.developers_with_callbacks.flat_map {|d| ["before_removing#{d.id}","after_removing#{d.id}"]}.sort
+    activerecord.developers_with_callbacks.flat_map { |d| ["before_removing#{d.id}", "after_removing#{d.id}"] }.sort
     assert activerecord.developers_with_callbacks.clear
-    assert_predicate activerecord.developers_log, :empty?
+    assert_empty activerecord.developers_log
   end
 
-  def test_has_many_and_belongs_to_many_callbacks_for_save_on_parent
-    project = Project.new :name => "Callbacks"
-    project.developers_with_callbacks.build :name => "Jack", :salary => 95000
+  def test_has_and_belongs_to_many_callbacks_for_save_on_parent
+    project = Project.new name: "Callbacks"
+    project.developers_with_callbacks.build name: "Jack", salary: 95000
 
     callback_log = ["before_adding<new>", "after_adding<new>"]
     assert_equal callback_log, project.developers_log
@@ -177,14 +195,14 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
   end
 
   def test_dont_add_if_before_callback_raises_exception
-    assert !@david.unchangeable_posts.include?(@authorless)
+    assert_not_includes @david.unchangeable_posts, @authorless
     begin
       @david.unchangeable_posts << @authorless
     rescue Exception
     end
-    assert @david.post_log.empty?
-    assert !@david.unchangeable_posts.include?(@authorless)
+    assert_empty @david.post_log
+    assert_not_includes @david.unchangeable_posts, @authorless
     @david.reload
-    assert !@david.unchangeable_posts.include?(@authorless)
+    assert_not_includes @david.unchangeable_posts, @authorless
   end
 end

data/test/cases/associations/cascaded_eager_loading_test.rb

@@ -1,56 +1,52 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/post'
-require 'models/comment'
-require 'models/author'
-require 'models/categorization'
-require 'models/category'
-require 'models/company'
-require 'models/topic'
-require 'models/reply'
-require 'models/person'
-require 'models/vertex'
-require 'models/edge'
+require "models/post"
+require "models/comment"
+require "models/author"
+require "models/categorization"
+require "models/category"
+require "models/company"
+require "models/topic"
+require "models/reply"
+require "models/person"
+require "models/vertex"
+require "models/edge"
 
 class CascadedEagerLoadingTest < ActiveRecord::TestCase
-  fixtures :authors, :mixins, :companies, :posts, :topics, :accounts, :comments,
+  fixtures :authors, :author_addresses, :mixins, :companies, :posts, :topics, :accounts, :comments,
            :categorizations, :people, :categories, :edges, :vertices
 
   def test_eager_association_loading_with_cascaded_two_levels
-    authors = Author.all.merge!(:includes=>{:posts=>:comments}, :order=>"authors.id").to_a
+    authors = Author.includes(posts: :comments).order(:id).to_a
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 11, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum, i| sum + i }
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_one_level
-    authors = Author.all.merge!(:includes=>[{:posts=>:comments}, :categorizations], :order=>"authors.id").to_a
+    authors = Author.includes({ posts: :comments }, :categorizations).order(:id).to_a
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 11, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum, i| sum + i }
     assert_equal 1, authors[0].categorizations.size
     assert_equal 2, authors[1].categorizations.size
   end
 
   def test_eager_association_loading_with_hmt_does_not_table_name_collide_when_joining_associations
-    assert_nothing_raised do
-      Author.joins(:posts).eager_load(:comments).where(:posts => {:tags_count => 1}).to_a
-    end
-    authors = Author.joins(:posts).eager_load(:comments).where(:posts => {:tags_count => 1}).to_a
-    assert_equal 1, assert_no_queries { authors.size }
-    assert_equal 10, assert_no_queries { authors[0].comments.size }
+    authors = Author.joins(:posts).eager_load(:comments).where(posts: { tags_count: 1 }).order(:id).to_a
+    assert_equal 3, assert_queries(0) { authors.size }
+    assert_equal 11, assert_queries(0) { authors[0].comments.size }
   end
 
   def test_eager_association_loading_grafts_stashed_associations_to_correct_parent
-    assert_nothing_raised do
-      Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').to_a
-    end
-    assert_equal people(:michael), Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').first
+    assert_equal people(:michael), Person.eager_load(primary_contact: :primary_contact).where("primary_contacts_people_2.first_name = ?", "Susan").order("people.id").first
   end
 
   def test_cascaded_eager_association_loading_with_join_for_count
-    categories = Category.joins(:categorizations).includes([{:posts=>:comments}, :authors])
+    categories = Category.joins(:categorizations).includes([{ posts: :comments }, :authors])
 
     assert_equal 4, categories.count
     assert_equal 4, categories.to_a.count
@@ -59,7 +55,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_cascaded_eager_association_loading_with_duplicated_includes
-    categories = Category.includes(:categorizations).includes(:categorizations => :author).where("categorizations.id is not null").references(:categorizations)
+    categories = Category.includes(:categorizations).includes(categorizations: :author).where("categorizations.id is not null").references(:categorizations)
     assert_nothing_raised do
       assert_equal 3, categories.count
       assert_equal 3, categories.to_a.size
@@ -67,7 +63,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_cascaded_eager_association_loading_with_twice_includes_edge_cases
-    categories = Category.includes(:categorizations => :author).includes(:categorizations => :post).where("posts.id is not null").references(:posts)
+    categories = Category.includes(categorizations: :author).includes(categorizations: :post).where("posts.id is not null").references(:posts)
     assert_nothing_raised do
       assert_equal 3, categories.count
       assert_equal 3, categories.to_a.size
@@ -82,107 +78,168 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
-    authors = Author.all.merge!(:includes=>{:posts=>[:comments, :categorizations]}, :order=>"authors.id").to_a
+    authors = Author.all.merge!(includes: { posts: [:comments, :categorizations] }, order: "authors.id").to_a
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 11, authors[0].posts.collect { |post| post.comments.size }.inject(0) { |sum, i| sum + i }
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_self_table_reference
-    authors = Author.all.merge!(:includes=>{:posts=>[:comments, :author]}, :order=>"authors.id").to_a
+    authors = Author.all.merge!(includes: { posts: [:comments, :author] }, order: "authors.id").to_a
     assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal authors(:david).name, authors[0].name
-    assert_equal [authors(:david).name], authors[0].posts.collect{|post| post.author.name}.uniq
+    assert_equal [authors(:david).name], authors[0].posts.collect { |post| post.author.name }.uniq
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_condition
-    authors = Author.all.merge!(:includes=>{:posts=>:comments}, :where=>"authors.id=1", :order=>"authors.id").to_a
+    authors = Author.all.merge!(includes: { posts: :comments }, where: "authors.id=1", order: "authors.id").to_a
     assert_equal 1, authors.size
     assert_equal 5, authors[0].posts.size
   end
 
   def test_eager_association_loading_with_cascaded_three_levels_by_ping_pong
-    firms = Firm.all.merge!(:includes=>{:account=>{:firm=>:account}}, :order=>"companies.id").to_a
-    assert_equal 2, firms.size
+    firms = Firm.all.merge!(includes: { account: { firm: :account } }, order: "companies.id").to_a
+    assert_equal 3, firms.size
     assert_equal firms.first.account, firms.first.account.firm.account
-    assert_equal companies(:first_firm).account, assert_no_queries { firms.first.account.firm.account }
-    assert_equal companies(:first_firm).account.firm.account, assert_no_queries { firms.first.account.firm.account }
+    assert_equal companies(:first_firm).account, assert_queries(0) { firms.first.account.firm.account }
+    assert_equal companies(:first_firm).account.firm.account, assert_queries(0) { firms.first.account.firm.account }
   end
 
   def test_eager_association_loading_with_has_many_sti
-    topics = Topic.all.merge!(:includes => :replies, :order => 'topics.id').to_a
+    topics = Topic.all.merge!(includes: :replies, order: "topics.id").to_a
     first, second, = topics(:first).replies.size, topics(:second).replies.size
-    assert_no_queries do
+    assert_queries(0) do
       assert_equal first, topics[0].replies.size
       assert_equal second, topics[1].replies.size
     end
   end
 
   def test_eager_association_loading_with_has_many_sti_and_subclasses
-    silly = SillyReply.new(:title => "gaga", :content => "boo-boo", :parent_id => 1)
-    silly.parent_id = 1
-    assert silly.save
+    reply = Reply.new(title: "gaga", content: "boo-boo", parent_id: 1)
+    assert reply.save
 
-    topics = Topic.all.merge!(:includes => :replies, :order => ['topics.id', 'replies_topics.id']).to_a
-    assert_no_queries do
+    topics = Topic.all.merge!(includes: :replies, order: ["topics.id", "replies_topics.id"]).to_a
+    assert_queries(0) do
       assert_equal 2, topics[0].replies.size
       assert_equal 0, topics[1].replies.size
     end
   end
 
   def test_eager_association_loading_with_belongs_to_sti
-    replies = Reply.all.merge!(:includes => :topic, :order => 'topics.id').to_a
-    assert replies.include?(topics(:second))
-    assert !replies.include?(topics(:first))
-    assert_equal topics(:first), assert_no_queries { replies.first.topic }
+    replies = Reply.all.merge!(includes: :topic, order: "topics.id").to_a
+    assert_includes replies, topics(:second)
+    assert_not_includes replies, topics(:first)
+    assert_equal topics(:first), assert_queries(0) { replies.first.topic }
   end
 
   def test_eager_association_loading_with_multiple_stis_and_order
-    author = Author.all.merge!(:includes => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :where => 'posts.id = 4').first
+    author = Author.all.merge!(includes: { posts: [ :special_comments, :very_special_comment ] }, order: ["authors.name", "comments.body", "very_special_comments_posts.body"], where: "posts.id = 4").first
     assert_equal authors(:david), author
-    assert_no_queries do
+    assert_queries(0) do
       author.posts.first.special_comments
       author.posts.first.very_special_comment
     end
   end
 
   def test_eager_association_loading_of_stis_with_multiple_references
-    authors = Author.all.merge!(:includes => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => 'comments.body, very_special_comments_posts.body', :where => 'posts.id = 4').to_a
+    authors = Author.all.merge!(includes: { posts: { special_comments: { post: [ :special_comments, :very_special_comment ] } } }, order: "comments.body, very_special_comments_posts.body", where: "posts.id = 4").to_a
     assert_equal [authors(:david)], authors
-    assert_no_queries do
+    assert_queries(0) do
       authors.first.posts.first.special_comments.first.post.special_comments
       authors.first.posts.first.special_comments.first.post.very_special_comment
     end
   end
 
   def test_eager_association_loading_where_first_level_returns_nil
-    authors = Author.all.merge!(:includes => {:post_about_thinking => :comments}, :order => 'authors.id DESC').to_a
+    authors = Author.all.merge!(includes: { post_about_thinking: :comments }, order: "authors.id DESC").to_a
     assert_equal [authors(:bob), authors(:mary), authors(:david)], authors
-    assert_no_queries do
+    assert_queries(0) do
       authors[2].post_about_thinking.comments.first
     end
   end
 
+  def test_preload_through_missing_records
+    post = Post.where.not(author_id: Author.select(:id)).preload(author: { comments: :post }).first!
+    assert_queries(0) { assert_nil post.author }
+  end
+
+  def test_eager_association_loading_with_missing_first_record
+    posts = Post.where(id: 3).preload(author: { comments: :post }).to_a
+    assert_equal posts.size, 1
+  end
+
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
-    source = Vertex.all.merge!(:includes=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id').first
-    assert_equal vertices(:vertex_4), assert_no_queries { source.sinks.first.sinks.first.sinks.first }
+    source = Vertex.all.merge!(includes: { sinks: { sinks: { sinks: :sinks } } }, order: "vertices.id").first
+    assert_equal vertices(:vertex_4), assert_queries(0) { source.sinks.first.sinks.first.sinks.first }
   end
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_and_belongs_to_many
-    sink = Vertex.all.merge!(:includes=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => 'vertices.id DESC').first
-    assert_equal vertices(:vertex_1), assert_no_queries { sink.sources.first.sources.first.sources.first.sources.first }
+    sink = Vertex.all.merge!(includes: { sources: { sources: { sources: :sources } } }, order: "vertices.id DESC").first
+    assert_equal vertices(:vertex_1), assert_queries(0) { sink.sources.first.sources.first.sources.first.sources.first }
   end
 
   def test_eager_association_loading_with_cascaded_interdependent_one_level_and_two_levels
     authors_relation = Author.all.merge!(includes: [:comments, { posts: :categorizations }], order: "authors.id")
     authors = authors_relation.to_a
     assert_equal 3, authors.size
-    assert_equal 10, authors[0].comments.size
+    assert_equal 11, authors[0].comments.size
     assert_equal 1, authors[1].comments.size
     assert_equal 5, authors[0].posts.size
     assert_equal 3, authors[1].posts.size
-    assert_equal 3, authors[0].posts.collect { |post| post.categorizations.size }.inject(0) { |sum, i| sum+i }
+    assert_equal 3, authors[0].posts.collect { |post| post.categorizations.size }.inject(0) { |sum, i| sum + i }
+  end
+
+  def test_preloaded_records_are_not_duplicated
+    author = Author.first
+    expected = Post.where(author: author)
+      .includes(author: :first_posts).map { |post| post.author.first_posts.size }
+    actual = author.posts
+      .includes(author: :first_posts).map { |post| post.author.first_posts.size }
+
+    assert_equal expected, actual
+  end
+
+  def test_preloading_across_has_one_constrains_loaded_records
+    author = authors(:david)
+
+    old_post = author.posts.create!(title: "first post", body: "test")
+    old_post.comments.create!(author: authors(:mary), body: "a response")
+
+    recent_post = author.posts.create!(title: "first post", body: "test")
+    last_comment = recent_post.comments.create!(author: authors(:bob), body: "a response")
+
+    authors = Author.where(id: author.id)
+    retrieved_comments = []
+
+    reset_callbacks(Comment, :initialize) do
+      Comment.after_initialize { |record| retrieved_comments << record }
+      authors.preload(recent_post: :comments).load
+    end
+
+    assert_equal 1, retrieved_comments.size
+    assert_equal [last_comment], retrieved_comments
+  end
+
+  def test_preloading_across_has_one_through_constrains_loaded_records
+    author = authors(:david)
+
+    old_post = author.posts.create!(title: "first post", body: "test")
+    old_post.comments.create!(author: authors(:mary), body: "a response")
+
+    recent_post = author.posts.create!(title: "first post", body: "test")
+    recent_post.comments.create!(author: authors(:bob), body: "a response")
+
+    authors = Author.where(id: author.id)
+    retrieved_authors = []
+
+    reset_callbacks(Author, :initialize) do
+      Author.after_initialize { |record| retrieved_authors << record }
+      authors.preload(recent_response: :author).load
+    end
+
+    assert_equal 2, retrieved_authors.size
+    assert_equal [author, authors(:bob)], retrieved_authors
   end
 end