ibm_db 5.1.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/nested_attributes_with_callbacks_test.rb

@@ -1,27 +1,29 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/pirate"
 require "models/bird"
 
 class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   Pirate.has_many(:birds_with_add_load,
-                  :class_name => "Bird",
-                  :before_add => proc { |p,b|
+                  class_name: "Bird",
+                  before_add: proc { |p, b|
                     @@add_callback_called << b
                     p.birds_with_add_load.to_a
                   })
   Pirate.has_many(:birds_with_add,
-                  :class_name => "Bird",
-                  :before_add => proc { |p,b| @@add_callback_called << b })
+                  class_name: "Bird",
+                  before_add: proc { |p, b| @@add_callback_called << b })
 
   Pirate.accepts_nested_attributes_for(:birds_with_add_load,
                                        :birds_with_add,
-                                       :allow_destroy => true)
+                                       allow_destroy: true)
 
   def setup
     @@add_callback_called = []
     @pirate = Pirate.new.tap do |pirate|
       pirate.catchphrase = "Don't call me!"
-      pirate.birds_attributes = [{:name => 'Bird1'},{:name => 'Bird2'}]
+      pirate.birds_attributes = [{ name: "Bird1" }, { name: "Bird2" }]
       pirate.save!
     end
     @birds = @pirate.birds.to_a
@@ -37,7 +39,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
 
   def existing_birds_attributes
     @birds.map do |bird|
-      bird.attributes.slice("id","name")
+      bird.attributes.slice("id", "name")
     end
   end
 
@@ -46,22 +48,22 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   end
 
   def new_bird_attributes
-     [{'name' => "New Bird"}]
+    [{ "name" => "New Bird" }]
   end
 
   def destroy_bird_attributes
-    [{'id' => bird_to_destroy.id.to_s, "_destroy" => true}]
+    [{ "id" => bird_to_destroy.id.to_s, "_destroy" => true }]
   end
 
   def update_new_and_destroy_bird_attributes
-    [{'id' => @birds[0].id.to_s, 'name' => 'New Name'},
-     {'name' => "New Bird"},
-     {'id' => bird_to_destroy.id.to_s, "_destroy" => true}]
+    [{ "id" => @birds[0].id.to_s, "name" => "New Name" },
+     { "name" => "New Bird" },
+     { "id" => bird_to_destroy.id.to_s, "_destroy" => true }]
   end
 
   # Characterizing when :before_add callback is called
   test ":before_add called for new bird when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = new_bird_attributes
     assert_new_bird_with_callback_called
   end
@@ -78,7 +80,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   end
 
   test ":before_add not called for identical assignment when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = existing_birds_attributes
     assert_callbacks_not_called
   end
@@ -90,7 +92,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   end
 
   test ":before_add not called for destroy assignment when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = destroy_bird_attributes
     assert_callbacks_not_called
   end
@@ -109,7 +111,7 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   # Ensuring that the records in the association target are updated,
   # whether the association is loaded before or not
   test "Assignment updates records in target when not loaded" do
-    assert_not @pirate.birds_with_add.loaded?
+    assert_not_predicate @pirate.birds_with_add, :loaded?
     @pirate.birds_with_add_attributes = update_new_and_destroy_bird_attributes
     assert_assignment_affects_records_in_target(:birds_with_add)
   end
@@ -120,14 +122,14 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
     assert_assignment_affects_records_in_target(:birds_with_add)
   end
 
-  test("Assignment updates records in target when not loaded" +
+  test("Assignment updates records in target when not loaded" \
        " and callback loads target") do
-    assert_not @pirate.birds_with_add_load.loaded?
+    assert_not_predicate @pirate.birds_with_add_load, :loaded?
     @pirate.birds_with_add_load_attributes = update_new_and_destroy_bird_attributes
     assert_assignment_affects_records_in_target(:birds_with_add_load)
   end
 
-  test("Assignment updates records in target when loaded" +
+  test("Assignment updates records in target when loaded" \
        " and callback loads target") do
     @pirate.birds_with_add_load.load_target
     @pirate.birds_with_add_load_attributes = update_new_and_destroy_bird_attributes
@@ -135,10 +137,10 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
   end
 
   def assert_assignment_affects_records_in_target(association_name)
-    association = @pirate.send(association_name)
-    assert association.detect {|b| b == bird_to_update }.name_changed?,
-      'Update record not updated'
-    assert association.detect {|b| b == bird_to_destroy }.marked_for_destruction?,
-      'Destroy record not marked for destruction'
+    association = @pirate.public_send(association_name)
+    assert association.detect { |b| b == bird_to_update }.name_changed?,
+      "Update record not updated"
+    assert association.detect { |b| b == bird_to_destroy }.marked_for_destruction?,
+      "Destroy record not marked for destruction"
   end
 end

data/test/cases/null_relation_test.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/developer"
+require "models/comment"
+require "models/post"
+require "models/topic"
+
+class NullRelationTest < ActiveRecord::TestCase
+  fixtures :posts, :comments
+
+  def test_none
+    assert_no_queries do
+      assert_equal [], Developer.none
+      assert_equal [], Developer.all.none
+    end
+  end
+
+  def test_none_chainable
+    assert_queries(0) do
+      assert_equal [], Developer.none.where(name: "David")
+    end
+  end
+
+  def test_none_chainable_to_existing_scope_extension_method
+    assert_no_queries do
+      assert_equal 1, Topic.anonymous_extension.none.one
+    end
+  end
+
+  def test_none_chained_to_methods_firing_queries_straight_to_db
+    assert_no_queries do
+      assert_equal [],    Developer.none.pluck(:id, :name)
+      assert_equal 0,     Developer.none.delete_all
+      assert_equal 0,     Developer.none.update_all(name: "David")
+      assert_equal 0,     Developer.none.delete(1)
+      assert_equal false, Developer.none.exists?(1)
+    end
+  end
+
+  def test_null_relation_content_size_methods
+    assert_no_queries do
+      assert_equal 0,     Developer.none.size
+      assert_equal 0,     Developer.none.count
+      assert_equal true,  Developer.none.empty?
+      assert_equal true,  Developer.none.none?
+      assert_equal false, Developer.none.any?
+      assert_equal false, Developer.none.one?
+      assert_equal false, Developer.none.many?
+    end
+  end
+
+  def test_null_relation_metadata_methods
+    assert_equal "", Developer.none.to_sql
+    assert_equal({}, Developer.none.where_values_hash)
+  end
+
+  def test_null_relation_where_values_hash
+    assert_equal({ "salary" => 100_000 }, Developer.none.where(salary: 100_000).where_values_hash)
+  end
+
+  [:count, :sum].each do |method|
+    define_method "test_null_relation_#{method}" do
+      assert_no_queries do
+        assert_equal 0, Comment.none.public_send(method, :id)
+        assert_equal Hash.new, Comment.none.group(:post_id).public_send(method, :id)
+      end
+    end
+  end
+
+  [:average, :minimum, :maximum].each do |method|
+    define_method "test_null_relation_#{method}" do
+      assert_no_queries do
+        assert_nil Comment.none.public_send(method, :id)
+        assert_equal Hash.new, Comment.none.group(:post_id).public_send(method, :id)
+      end
+    end
+  end
+
+  def test_null_relation_in_where_condition
+    assert_operator Comment.count, :>, 0 # precondition, make sure there are comments.
+    assert_equal 0, Comment.where(post_id: Post.none).count
+  end
+end

data/test/cases/numeric_data_test.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/numeric_data"
+
+class NumericDataTest < ActiveRecord::TestCase
+  def test_big_decimal_conditions
+    m = NumericData.new(
+      bank_balance: 1586.43,
+      big_bank_balance: BigDecimal("1000234000567.95"),
+      world_population: 6000000000,
+      my_house_population: 3
+    )
+    assert m.save
+    assert_equal 0, NumericData.where("bank_balance > ?", 2000.0).count
+  end
+
+  def test_numeric_fields
+    m = NumericData.new(
+      bank_balance: 1586.43,
+      big_bank_balance: BigDecimal("1000234000567.95"),
+      world_population: 2**62,
+      my_house_population: 3
+    )
+    assert m.save
+
+    m1 = NumericData.find_by(
+      bank_balance: 1586.43,
+      big_bank_balance: BigDecimal("1000234000567.95")
+    )
+
+    assert_kind_of Integer, m1.world_population
+    assert_equal 2**62, m1.world_population
+
+    assert_kind_of Integer, m1.my_house_population
+    assert_equal 3, m1.my_house_population
+
+    assert_kind_of BigDecimal, m1.bank_balance
+    assert_equal BigDecimal("1586.43"), m1.bank_balance
+
+    assert_kind_of BigDecimal, m1.big_bank_balance
+    assert_equal BigDecimal("1000234000567.95"), m1.big_bank_balance
+  end
+
+  def test_numeric_fields_with_scale
+    m = NumericData.new(
+      bank_balance: 1586.43122334,
+      big_bank_balance: BigDecimal("234000567.952344"),
+      world_population: 2**62,
+      my_house_population: 3
+    )
+    assert m.save
+
+    m1 = NumericData.find_by(
+      bank_balance: 1586.43122334,
+      big_bank_balance: BigDecimal("234000567.952344")
+    )
+
+    assert_kind_of Integer, m1.world_population
+    assert_equal 2**62, m1.world_population
+
+    assert_kind_of Integer, m1.my_house_population
+    assert_equal 3, m1.my_house_population
+
+    assert_kind_of BigDecimal, m1.bank_balance
+    assert_equal BigDecimal("1586.43"), m1.bank_balance
+
+    assert_kind_of BigDecimal, m1.big_bank_balance
+    assert_equal BigDecimal("234000567.95"), m1.big_bank_balance
+  end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_numeric_fields_with_nan
+      m = NumericData.new(
+        bank_balance: BigDecimal("NaN"),
+        big_bank_balance: BigDecimal("NaN"),
+        world_population: 2**62,
+        my_house_population: 3
+      )
+      assert_predicate m.bank_balance, :nan?
+      assert_predicate m.big_bank_balance, :nan?
+      assert m.save
+
+      m1 = NumericData.find_by(
+        bank_balance: BigDecimal("NaN"),
+        big_bank_balance: BigDecimal("NaN")
+      )
+
+      assert_predicate m1.bank_balance, :nan?
+      assert_predicate m1.big_bank_balance, :nan?
+    end
+  end
+end