ibm_db 5.1.0 → 5.3.1

data/test/cases/associations/eager_load_includes_full_sti_class_test.rb

@@ -1,36 +1,156 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/tagging'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/tagging"
 
 module Namespaced
   class Post < ActiveRecord::Base
-    self.table_name = 'posts'
-    has_one :tagging, :as => :taggable, :class_name => 'Tagging'
+    self.table_name = "posts"
+    has_one :tagging, as: :taggable, class_name: "Tagging"
   end
 end
 
-class EagerLoadIncludeFullStiClassNamesTest < ActiveRecord::TestCase
+module FullStiClassNamesSharedTest
+  def setup
+    @old_store_full_sti_class = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = store_full_sti_class
+
+    post = Namespaced::Post.create(title: "Great stuff", body: "This is not", author_id: 1)
+    @tagging = post.create_tagging!
+  end
+
+  def teardown
+    ActiveRecord::Base.store_full_sti_class = @old_store_full_sti_class
+  end
+
+  def test_class_names
+    ActiveRecord::Base.store_full_sti_class = !store_full_sti_class
+    post = Namespaced::Post.find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+
+    ActiveRecord::Base.store_full_sti_class = store_full_sti_class
+    post = Namespaced::Post.find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
+
+  def test_class_names_with_includes
+    ActiveRecord::Base.store_full_sti_class = !store_full_sti_class
+    post = Namespaced::Post.includes(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
 
+    ActiveRecord::Base.store_full_sti_class = store_full_sti_class
+    post = Namespaced::Post.includes(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
+
+  def test_class_names_with_eager_load
+    ActiveRecord::Base.store_full_sti_class = !store_full_sti_class
+    post = Namespaced::Post.eager_load(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+
+    ActiveRecord::Base.store_full_sti_class = store_full_sti_class
+    post = Namespaced::Post.eager_load(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
+
+  def test_class_names_with_find_by
+    post = Namespaced::Post.find_by_title("Great stuff")
+
+    ActiveRecord::Base.store_full_sti_class = !store_full_sti_class
+    assert_equal @tagging, Tagging.find_by(taggable: post)
+
+    ActiveRecord::Base.store_full_sti_class = store_full_sti_class
+    assert_equal @tagging, Tagging.find_by(taggable: post)
+  end
+end
+
+class FullStiClassNamesTest < ActiveRecord::TestCase
+  include FullStiClassNamesSharedTest
+
+  private
+    def store_full_sti_class
+      true
+    end
+end
+
+class NonFullStiClassNamesTest < ActiveRecord::TestCase
+  include FullStiClassNamesSharedTest
+
+  private
+    def store_full_sti_class
+      false
+    end
+end
+
+module PolymorphicFullClassNamesSharedTest
   def setup
-    generate_test_objects
+    @old_store_full_class_name = ActiveRecord::Base.store_full_class_name
+    ActiveRecord::Base.store_full_class_name = store_full_class_name
+
+    post = Namespaced::Post.create(title: "Great stuff", body: "This is not", author_id: 1)
+    @tagging = post.create_tagging!
   end
 
-  def generate_test_objects
-    post = Namespaced::Post.create( :title => 'Great stuff', :body => 'This is not', :author_id => 1 )
-    Tagging.create( :taggable => post )
+  def teardown
+    ActiveRecord::Base.store_full_class_name = @old_store_full_class_name
   end
 
   def test_class_names
-    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_class_name = !store_full_class_name
+    post = Namespaced::Post.find_by_title("Great stuff")
+    assert_nil post.tagging
+
+    ActiveRecord::Base.store_full_class_name = store_full_class_name
+    post = Namespaced::Post.find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
+
+  def test_class_names_with_includes
+    ActiveRecord::Base.store_full_class_name = !store_full_class_name
+    post = Namespaced::Post.includes(:tagging).find_by_title("Great stuff")
+    assert_nil post.tagging
+
+    ActiveRecord::Base.store_full_class_name = store_full_class_name
+    post = Namespaced::Post.includes(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
 
-    ActiveRecord::Base.store_full_sti_class = false
-    post = Namespaced::Post.includes(:tagging).find_by_title('Great stuff')
+  def test_class_names_with_eager_load
+    ActiveRecord::Base.store_full_class_name = !store_full_class_name
+    post = Namespaced::Post.eager_load(:tagging).find_by_title("Great stuff")
     assert_nil post.tagging
 
-    ActiveRecord::Base.store_full_sti_class = true
-    post = Namespaced::Post.includes(:tagging).find_by_title('Great stuff')
-    assert_instance_of Tagging, post.tagging
-  ensure
-    ActiveRecord::Base.store_full_sti_class = old
+    ActiveRecord::Base.store_full_class_name = store_full_class_name
+    post = Namespaced::Post.eager_load(:tagging).find_by_title("Great stuff")
+    assert_equal @tagging, post.tagging
+  end
+
+  def test_class_names_with_find_by
+    post = Namespaced::Post.find_by_title("Great stuff")
+
+    ActiveRecord::Base.store_full_class_name = !store_full_class_name
+    assert_nil Tagging.find_by(taggable: post)
+
+    ActiveRecord::Base.store_full_class_name = store_full_class_name
+    assert_equal @tagging, Tagging.find_by(taggable: post)
   end
 end
+
+class PolymorphicFullClassNamesTest < ActiveRecord::TestCase
+  include PolymorphicFullClassNamesSharedTest
+
+  private
+    def store_full_class_name
+      true
+    end
+end
+
+class PolymorphicNonFullClassNamesTest < ActiveRecord::TestCase
+  include PolymorphicFullClassNamesSharedTest
+
+  private
+    def store_full_class_name
+      false
+    end
+end

data/test/cases/associations/eager_load_nested_include_test.rb

@@ -1,52 +1,55 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/tag'
-require 'models/author'
-require 'models/comment'
-require 'models/category'
-require 'models/categorization'
-require 'models/tagging'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/tag"
+require "models/author"
+require "models/comment"
+require "models/category"
+require "models/categorization"
+require "models/tagging"
 
 module Remembered
   extend ActiveSupport::Concern
 
   included do
     after_create :remember
-  protected
+
+  private
     def remember; self.class.remembered << self; end
   end
 
   module ClassMethods
-    def remembered; @@remembered ||= []; end
-    def sample; @@remembered.sample; end
+    def remembered; @remembered ||= []; end
+    def sample; remembered.sample; end
   end
 end
 
 class ShapeExpression < ActiveRecord::Base
-  belongs_to :shape, :polymorphic => true
-  belongs_to :paint, :polymorphic => true
+  belongs_to :shape, polymorphic: true
+  belongs_to :paint, polymorphic: true
 end
 
 class Circle < ActiveRecord::Base
-  has_many :shape_expressions, :as => :shape
+  has_many :shape_expressions, as: :shape
   include Remembered
 end
 class Square < ActiveRecord::Base
-  has_many :shape_expressions, :as => :shape
+  has_many :shape_expressions, as: :shape
   include Remembered
 end
 class Triangle < ActiveRecord::Base
-  has_many :shape_expressions, :as => :shape
+  has_many :shape_expressions, as: :shape
   include Remembered
 end
-class PaintColor  < ActiveRecord::Base
-  has_many   :shape_expressions, :as => :paint
-  belongs_to :non_poly, :foreign_key => "non_poly_one_id", :class_name => "NonPolyOne"
+class PaintColor < ActiveRecord::Base
+  has_many   :shape_expressions, as: :paint
+  belongs_to :non_poly, foreign_key: "non_poly_one_id", class_name: "NonPolyOne"
   include Remembered
 end
 class PaintTexture < ActiveRecord::Base
-  has_many   :shape_expressions, :as => :paint
-  belongs_to :non_poly, :foreign_key => "non_poly_two_id", :class_name => "NonPolyTwo"
+  has_many   :shape_expressions, as: :paint
+  belongs_to :non_poly, foreign_key: "non_poly_two_id", class_name: "NonPolyTwo"
   include Remembered
 end
 class NonPolyOne < ActiveRecord::Base
@@ -58,8 +61,6 @@ class NonPolyTwo < ActiveRecord::Base
   include Remembered
 end
 
-
-
 class EagerLoadPolyAssocsTest < ActiveRecord::TestCase
   NUM_SIMPLE_OBJS = 50
   NUM_SHAPE_EXPRESSIONS = 100
@@ -78,21 +79,21 @@ class EagerLoadPolyAssocsTest < ActiveRecord::TestCase
       [Circle, Square, Triangle, NonPolyOne, NonPolyTwo].map(&:create!)
     end
     1.upto(NUM_SIMPLE_OBJS) do
-      PaintColor.create!(:non_poly_one_id => NonPolyOne.sample.id)
-      PaintTexture.create!(:non_poly_two_id => NonPolyTwo.sample.id)
+      PaintColor.create!(non_poly_one_id: NonPolyOne.sample.id)
+      PaintTexture.create!(non_poly_two_id: NonPolyTwo.sample.id)
     end
     1.upto(NUM_SHAPE_EXPRESSIONS) do
       shape_type = [Circle, Square, Triangle].sample
       paint_type = [PaintColor, PaintTexture].sample
-      ShapeExpression.create!(:shape_type => shape_type.to_s, :shape_id => shape_type.sample.id,
-                              :paint_type => paint_type.to_s, :paint_id => paint_type.sample.id)
+      ShapeExpression.create!(shape_type: shape_type.to_s, shape_id: shape_type.sample.id,
+                              paint_type: paint_type.to_s, paint_id: paint_type.sample.id)
     end
   end
 
   def test_include_query
-    res = ShapeExpression.all.merge!(:includes => [ :shape, { :paint => :non_poly } ]).to_a
+    res = ShapeExpression.all.merge!(includes: [ :shape, { paint: :non_poly } ]).to_a
     assert_equal NUM_SHAPE_EXPRESSIONS, res.size
-    assert_queries(0) do
+    assert_no_queries do
       res.each do |se|
         assert_not_nil se.paint.non_poly, "this is the association that was loading incorrectly before the change"
         assert_not_nil se.shape, "just making sure other associations still work"
@@ -103,24 +104,24 @@ end
 
 class EagerLoadNestedIncludeWithMissingDataTest < ActiveRecord::TestCase
   def setup
-    @davey_mcdave = Author.create(:name => 'Davey McDave')
-    @first_post = @davey_mcdave.posts.create(:title => 'Davey Speaks', :body => 'Expressive wordage')
-    @first_comment = @first_post.comments.create(:body => 'Inflamatory doublespeak')
-    @first_categorization = @davey_mcdave.categorizations.create(:category => Category.first, :post => @first_post)
+    @davey_mcdave = Author.create(name: "Davey McDave")
+    @first_post = @davey_mcdave.posts.create(title: "Davey Speaks", body: "Expressive wordage")
+    @first_comment = @first_post.comments.create(body: "Inflamatory doublespeak")
+    @first_categorization = @davey_mcdave.categorizations.create(category: Category.first, post: @first_post)
   end
 
   teardown do
-    @davey_mcdave.destroy
-    @first_post.destroy
     @first_comment.destroy
     @first_categorization.destroy
+    @davey_mcdave.destroy
+    @first_post.destroy
   end
 
   def test_missing_data_in_a_nested_include_should_not_cause_errors_when_constructing_objects
     assert_nothing_raised do
       # @davey_mcdave doesn't have any author_favorites
-      includes = {:posts => :comments, :categorizations => :category, :author_favorites => :favorite_author }
-      Author.all.merge!(:includes => includes, :where => {:authors => {:name => @davey_mcdave.name}}, :order => 'categories.name').to_a
+      includes = { posts: :comments, categorizations: :category, author_favorites: :favorite_author }
+      Author.all.merge!(includes: includes, where: { authors: { name: @davey_mcdave.name } }, order: "categories.name").to_a
     end
   end
 end

data/test/cases/associations/eager_singularization_test.rb

@@ -1,7 +1,7 @@
-require "cases/helper"
+# frozen_string_literal: true
 
+require "cases/helper"
 
-if ActiveRecord::Base.connection.supports_migrations?
 class EagerSingularizationTest < ActiveRecord::TestCase
   class Virus < ActiveRecord::Base
     belongs_to :octopus
@@ -25,10 +25,10 @@ class EagerSingularizationTest < ActiveRecord::TestCase
 
   class Crisis < ActiveRecord::Base
     has_and_belongs_to_many :messes
-    has_many :analyses, :dependent => :destroy
-    has_many :successes, :through => :analyses
-    has_many :dresses, :dependent => :destroy
-    has_many :compresses, :through => :dresses
+    has_many :analyses, dependent: :destroy
+    has_many :successes, through: :analyses
+    has_many :dresses, dependent: :destroy
+    has_many :compresses, through: :dresses
   end
 
   class Analysis < ActiveRecord::Base
@@ -37,8 +37,8 @@ class EagerSingularizationTest < ActiveRecord::TestCase
   end
 
   class Success < ActiveRecord::Base
-    has_many :analyses, :dependent => :destroy
-    has_many :crises, :through => :analyses
+    has_many :analyses, dependent: :destroy
+    has_many :crises, through: :analyses
   end
 
   class Dress < ActiveRecord::Base
@@ -65,7 +65,7 @@ class EagerSingularizationTest < ActiveRecord::TestCase
     connection.create_table :buses do |t|
       t.column :name, :string
     end
-    connection.create_table :crises_messes, :id => false do |t|
+    connection.create_table :crises_messes, id: false do |t|
       t.column :crisis_id, :integer
       t.column :mess_id, :integer
     end
@@ -104,45 +104,45 @@ class EagerSingularizationTest < ActiveRecord::TestCase
     connection.drop_table :compresses
   end
 
-  def connection
-    ActiveRecord::Base.connection
-  end
-
   def test_eager_no_extra_singularization_belongs_to
     assert_nothing_raised do
-      Virus.all.merge!(:includes => :octopus).to_a
+      Virus.all.merge!(includes: :octopus).to_a
     end
   end
 
   def test_eager_no_extra_singularization_has_one
     assert_nothing_raised do
-      Octopus.all.merge!(:includes => :virus).to_a
+      Octopus.all.merge!(includes: :virus).to_a
     end
   end
 
   def test_eager_no_extra_singularization_has_many
     assert_nothing_raised do
-      Bus.all.merge!(:includes => :passes).to_a
+      Bus.all.merge!(includes: :passes).to_a
     end
   end
 
   def test_eager_no_extra_singularization_has_and_belongs_to_many
     assert_nothing_raised do
-      Crisis.all.merge!(:includes => :messes).to_a
-      Mess.all.merge!(:includes => :crises).to_a
+      Crisis.all.merge!(includes: :messes).to_a
+      Mess.all.merge!(includes: :crises).to_a
     end
   end
 
   def test_eager_no_extra_singularization_has_many_through_belongs_to
     assert_nothing_raised do
-      Crisis.all.merge!(:includes => :successes).to_a
+      Crisis.all.merge!(includes: :successes).to_a
     end
   end
 
   def test_eager_no_extra_singularization_has_many_through_has_many
     assert_nothing_raised do
-      Crisis.all.merge!(:includes => :compresses).to_a
+      Crisis.all.merge!(includes: :compresses).to_a
     end
   end
-end
+
+  private
+    def connection
+      ActiveRecord::Base.connection
+    end
 end