ibm_db 5.6.1 → 5.7.0

data/test/cases/shard_keys_test.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class ShardsKeysTest < ActiveRecord::TestCase
+    class UnshardedBase < ActiveRecord::Base
+      self.abstract_class = true
+    end
+
+    class UnshardedModel < UnshardedBase
+    end
+
+    class ShardedBase < ActiveRecord::Base
+      self.abstract_class = true
+    end
+
+    class ShardedModel < ShardedBase
+    end
+
+    def setup
+      ActiveRecord::Base.instance_variable_set(:@shard_keys, nil)
+      @previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "default_env"
+
+      config = {
+        "default_env" => {
+          "primary" => {
+            adapter: "sqlite3",
+            database: ":memory:"
+          },
+          "shard_one" => {
+            adapter: "sqlite3",
+            database: ":memory:"
+          },
+          "shard_one_reading" => {
+            adapter: "sqlite3",
+            database: ":memory:"
+          },
+          "shard_two" => {
+            adapter: "sqlite3",
+            database: ":memory:"
+          },
+          "shard_two_reading" => {
+            adapter: "sqlite3",
+            database: ":memory:"
+          },
+        }
+      }
+
+      @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+      UnshardedBase.connects_to database: { writing: :primary }
+
+      ShardedBase.connects_to shards: {
+        shard_one: { writing: :shard_one, reading: :shard_one_reading },
+        shard_two: { writing: :shard_two, reading: :shard_two_reading },
+      }
+    end
+
+    def teardown
+      clean_up_connection_handler
+      ActiveRecord::Base.configurations = @prev_configs
+      ActiveRecord::Base.establish_connection(:arunit)
+      ENV["RAILS_ENV"] = @previous_env
+    end
+
+    def test_connects_to_sets_shard_keys
+      assert_empty(ActiveRecord::Base.shard_keys)
+      assert_equal([:shard_one, :shard_two], ShardedBase.shard_keys)
+    end
+
+    def test_connects_to_sets_shard_keys_for_descendents
+      assert_equal(ShardedBase.shard_keys, ShardedModel.shard_keys)
+    end
+
+    def test_sharded?
+      assert_not ActiveRecord::Base.sharded?
+      assert_not UnshardedBase.sharded?
+      assert_not UnshardedModel.sharded?
+
+      assert_predicate ShardedBase, :sharded?
+      assert_predicate ShardedModel, :sharded?
+    end
+
+    def test_connected_to_all_shards
+      unsharded_results = UnshardedBase.connected_to_all_shards do
+        UnshardedBase.connection_pool.db_config.name
+      end
+
+      sharded_results = ShardedBase.connected_to_all_shards do
+        ShardedBase.connection_pool.db_config.name
+      end
+
+      assert_empty unsharded_results
+      assert_equal(["shard_one", "shard_two"], sharded_results)
+    end
+
+    def test_connected_to_all_shards_can_switch_each_to_reading_role
+      # We teardown the shared connection pool and call .connects_to again
+      # because .setup_shared_connection_pool overwrites our reading configs
+      # with the writing role configs.
+      teardown_shared_connection_pool
+      ShardedBase.connects_to shards: {
+        shard_one: { writing: :shard_one, reading: :shard_one_reading },
+        shard_two: { writing: :shard_two, reading: :shard_two_reading },
+      }
+
+      results = ShardedBase.connected_to_all_shards(role: :reading) do
+        ShardedBase.connection_pool.db_config.name
+      end
+
+      assert_equal(["shard_one_reading", "shard_two_reading"], results)
+    end
+
+    def test_connected_to_all_shards_respects_preventing_writes
+      assert_not ShardedBase.current_preventing_writes
+
+      results = ShardedBase.connected_to_all_shards(role: :writing, prevent_writes: true) do
+        ShardedBase.current_preventing_writes
+      end
+
+      assert_equal([true, true], results)
+    end
+  end
+end

data/test/cases/shard_selector_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/person"
+require "action_dispatch"
+
+module ActiveRecord
+  class ShardSelectorTest < ActiveRecord::TestCase
+    def test_middleware_locks_to_shard_by_default
+      middleware = ActiveRecord::Middleware::ShardSelector.new(lambda { |env|
+        assert_predicate ActiveRecord::Base, :shard_swapping_prohibited?
+        [200, {}, ["body"]]
+      }, ->(*) { :shard_one })
+
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+    end
+
+    def test_middleware_can_turn_off_lock_option
+      middleware = ActiveRecord::Middleware::ShardSelector.new(lambda { |env|
+        assert_not_predicate ActiveRecord::Base, :shard_swapping_prohibited?
+        [200, {}, ["body"]]
+      }, ->(*) { :shard_one }, { lock: false })
+
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+    end
+
+    def test_middleware_can_change_shards
+      middleware = ActiveRecord::Middleware::ShardSelector.new(lambda { |env|
+        assert ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one)
+        [200, {}, ["body"]]
+      }, ->(*) { :shard_one })
+
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+    end
+
+    def test_middleware_can_handle_string_shards
+      middleware = ActiveRecord::Middleware::ShardSelector.new(lambda { |env|
+        assert ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one)
+        [200, {}, ["body"]]
+      }, ->(*) { "shard_one" })
+
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+    end
+  end
+end

data/test/cases/signed_id_test.rb

@@ -5,17 +5,30 @@ require "models/account"
 require "models/company"
 require "models/toy"
 require "models/matey"
+require "models/cpk"
 
 SIGNED_ID_VERIFIER_TEST_SECRET = -> { "This is normally set by the railtie initializer when used with Rails!" }
 
 ActiveRecord::Base.signed_id_verifier_secret = SIGNED_ID_VERIFIER_TEST_SECRET
 
 class SignedIdTest < ActiveRecord::TestCase
-  fixtures :accounts, :toys, :companies
+  class GetSignedIDInCallback < ActiveRecord::Base
+    self.table_name = "accounts"
+    after_create :set_signed_id
+    attr_reader :signed_id_from_callback
+
+    private
+      def set_signed_id
+        @signed_id_from_callback = signed_id
+      end
+  end
+
+  fixtures :accounts, :toys, :companies, :cpk_orders
 
   setup do
     @account = Account.first
     @toy = Toy.first
+    @cpk_order = Cpk::Order.first
   end
 
   test "find signed record" do
@@ -32,6 +45,16 @@ class SignedIdTest < ActiveRecord::TestCase
     assert_equal @toy, Toy.find_signed(@toy.signed_id)
   end
 
+  test "find signed record with composite primary key" do
+    assert_equal @cpk_order, Cpk::Order.find_signed(@cpk_order.signed_id)
+  end
+
+  test "find signed record on relation with composite primary key" do
+    assert_equal @cpk_order, Cpk::Order.where("1=1").find_signed(@cpk_order.signed_id)
+
+    assert_nil Cpk::Order.where("1=0").find_signed(@cpk_order.signed_id)
+  end
+
   test "find signed record for single table inheritance (STI Models)" do
     assert_equal Company.first, Company.find_signed(Company.first.signed_id)
   end
@@ -59,6 +82,10 @@ class SignedIdTest < ActiveRecord::TestCase
     assert_equal @toy, Toy.find_signed!(@toy.signed_id)
   end
 
+  test "find signed record with a bang with composite primary key" do
+    assert_equal @cpk_order, Cpk::Order.find_signed!(@cpk_order.signed_id)
+  end
+
   test "find signed record with a bang for single table inheritance (STI Models)" do
     assert_equal Company.first, Company.find_signed!(Company.first.signed_id)
   end
@@ -67,11 +94,11 @@ class SignedIdTest < ActiveRecord::TestCase
     assert_nil Account.find_signed("this won't find anything")
   end
 
-  test "find signed record within expiration date" do
+  test "find signed record within expiration duration" do
     assert_equal @account, Account.find_signed(@account.signed_id(expires_in: 1.minute))
   end
 
-  test "fail to find signed record within expiration date" do
+  test "fail to find signed record within expiration duration" do
     signed_id = @account.signed_id(expires_in: 1.minute)
     travel 2.minutes
     assert_nil Account.find_signed(signed_id)
@@ -83,6 +110,16 @@ class SignedIdTest < ActiveRecord::TestCase
     assert_nil Account.find_signed signed_id
   end
 
+  test "find signed record within expiration time" do
+    assert_equal @account, Account.find_signed(@account.signed_id(expires_at: 1.minute.from_now))
+  end
+
+  test "fail to find signed record within expiration time" do
+    signed_id = @account.signed_id(expires_at: 1.minute.from_now)
+    travel 2.minutes
+    assert_nil Account.find_signed(signed_id)
+  end
+
   test "find signed record with purpose" do
     assert_equal @account, Account.find_signed(@account.signed_id(purpose: :v1), purpose: :v1)
   end
@@ -99,11 +136,11 @@ class SignedIdTest < ActiveRecord::TestCase
     end
   end
 
-  test "find signed record with a bang within expiration date" do
+  test "find signed record with a bang within expiration duration" do
     assert_equal @account, Account.find_signed!(@account.signed_id(expires_in: 1.minute))
   end
 
-  test "finding signed record outside expiration date raises on the bang" do
+  test "finding signed record outside expiration duration raises on the bang" do
     signed_id = @account.signed_id(expires_in: 1.minute)
     travel 2.minutes
 
@@ -157,6 +194,11 @@ class SignedIdTest < ActiveRecord::TestCase
     ActiveRecord::Base.signed_id_verifier_secret = SIGNED_ID_VERIFIER_TEST_SECRET
   end
 
+  test "always output url_safe" do
+    signed_id = @account.signed_id(purpose: "~~~~~~~~~")
+    assert_not signed_id.include?("+")
+  end
+
   test "use a custom verifier" do
     old_verifier = Account.signed_id_verifier
     Account.signed_id_verifier = ActiveSupport::MessageVerifier.new("sekret")
@@ -165,4 +207,14 @@ class SignedIdTest < ActiveRecord::TestCase
   ensure
     Account.signed_id_verifier = old_verifier
   end
+
+  test "cannot get a signed ID for a new record" do
+    assert_raises ArgumentError, match: /Cannot get a signed_id for a new record/ do
+      Account.new.signed_id
+    end
+  end
+
+  test "can get a signed ID in an after_create" do
+    assert_not_nil GetSignedIDInCallback.create.signed_id_from_callback
+  end
 end

data/test/cases/statement_cache_test.rb

@@ -6,24 +6,25 @@ require "models/liquid"
 require "models/molecule"
 require "models/numeric_data"
 require "models/electron"
+require "models/clothing_item"
 
 module ActiveRecord
   class StatementCacheTest < ActiveRecord::TestCase
     def setup
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
     end
 
     def test_statement_cache
       Book.create(name: "my book")
       Book.create(name: "my other book")
 
-      cache = StatementCache.create(Book.connection) do |params|
+      cache = StatementCache.create(ClothingItem.lease_connection) do |params|
         Book.where(name: params.bind)
       end
 
-      b = cache.execute([ "my book" ], Book.connection)
+      b = cache.execute([ "my book" ], ClothingItem.lease_connection)
       assert_equal "my book", b[0].name
-      b = cache.execute([ "my other book" ], Book.connection)
+      b = cache.execute([ "my other book" ], ClothingItem.lease_connection)
       assert_equal "my other book", b[0].name
     end
 
@@ -31,13 +32,13 @@ module ActiveRecord
       b1 = Book.create(name: "my book")
       b2 = Book.create(name: "my other book")
 
-      cache = StatementCache.create(Book.connection) do |params|
+      cache = StatementCache.create(ClothingItem.lease_connection) do |params|
         Book.where(id: params.bind)
       end
 
-      b = cache.execute([ b1.id ], Book.connection)
+      b = cache.execute([ b1.id ], ClothingItem.lease_connection)
       assert_equal b1.name, b[0].name
-      b = cache.execute([ b2.id ], Book.connection)
+      b = cache.execute([ b2.id ], ClothingItem.lease_connection)
       assert_equal b2.name, b[0].name
     end
 
@@ -52,18 +53,18 @@ module ActiveRecord
     end
 
     def test_statement_cache_with_simple_statement
-      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
+      cache = ActiveRecord::StatementCache.create(ClothingItem.lease_connection) do |params|
         Book.where(name: "my book").where("author_id > 3")
       end
 
       Book.create(name: "my book", author_id: 4)
 
-      books = cache.execute([], Book.connection)
+      books = cache.execute([], ClothingItem.lease_connection)
       assert_equal "my book", books[0].name
     end
 
     def test_statement_cache_with_complex_statement
-      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
+      cache = ActiveRecord::StatementCache.create(ClothingItem.lease_connection) do |params|
         Liquid.joins(molecules: :electrons).where("molecules.name" => "dioxane", "electrons.name" => "lepton")
       end
 
@@ -71,7 +72,7 @@ module ActiveRecord
       molecule = salty.molecules.create(name: "dioxane")
       molecule.electrons.create(name: "lepton")
 
-      liquids = cache.execute([], Book.connection)
+      liquids = cache.execute([], ClothingItem.lease_connection)
       assert_equal "salty", liquids[0].name
     end
 
@@ -81,22 +82,22 @@ module ActiveRecord
     end
 
     def test_statement_cache_values_differ
-      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
+      cache = ActiveRecord::StatementCache.create(ClothingItem.lease_connection) do |params|
         Book.where(name: "my book")
       end
 
-      3.times do
-        Book.create(name: "my book")
+      3.times do |i|
+        Book.create(name: "my book", author_id: i)
       end
 
-      first_books = cache.execute([], Book.connection)
+      first_books = cache.execute([], ClothingItem.lease_connection)
 
-      3.times do
-        Book.create(name: "my book")
+      3.times do |i|
+        Book.create(name: "my book", author_id: i + 3)
       end
 
-      additional_books = cache.execute([], Book.connection)
-      assert first_books != additional_books
+      additional_books = cache.execute([], ClothingItem.lease_connection)
+      assert_not_equal first_books, additional_books
     end
 
     def test_unprepared_statements_dont_share_a_cache_with_prepared_statements
@@ -104,7 +105,7 @@ module ActiveRecord
       Book.create(name: "my other book")
 
       book = Book.find_by(name: "my book")
-      other_book = Book.connection.unprepared_statement do
+      other_book = Book.lease_connection.unprepared_statement do
         Book.find_by(name: "my other book")
       end
 
@@ -112,29 +113,29 @@ module ActiveRecord
     end
 
     def test_find_by_does_not_use_statement_cache_if_table_name_is_changed
-      book = Book.create(name: "my book")
+      liquid = Liquid.create(name: "salty")
 
-      Book.find_by(name: book.name) # warming the statement cache.
+      Liquid.find_by(name: liquid.name) # warming the statement cache.
 
       # changing the table name should change the query that is not cached.
-      Book.table_name = :birds
-      assert_nil Book.find_by(name: book.name)
+      Liquid.table_name = :birds
+      assert_nil Liquid.find_by(name: liquid.name)
     ensure
-      Book.table_name = :books
+      Liquid.table_name = :liquid
     end
 
     def test_find_does_not_use_statement_cache_if_table_name_is_changed
-      book = Book.create(name: "my book")
+      liquid = Liquid.create(name: "salty")
 
-      Book.find(book.id) # warming the statement cache.
+      Liquid.find(liquid.id) # warming the statement cache.
 
       # changing the table name should change the query that is not cached.
-      Book.table_name = :birds
+      Liquid.table_name = :birds
       assert_raise ActiveRecord::RecordNotFound do
-        Book.find(book.id)
+        Liquid.find(liquid.id)
       end
     ensure
-      Book.table_name = :books
+      Liquid.table_name = :liquid
     end
 
     def test_find_association_does_not_use_statement_cache_if_table_name_is_changed

data/test/cases/statement_invalid_test.rb

@@ -20,8 +20,10 @@ module ActiveRecord
     test "message contains no sql" do
       sql = Book.where(author_id: 96, cover: "hard").to_sql
       error = assert_raises(ActiveRecord::StatementInvalid) do
-        Book.connection.send(:log, sql, Book.name) do
-          raise MockDatabaseError
+        Book.lease_connection.send(:log, sql, Book.name) do
+          Book.lease_connection.send(:with_raw_connection) do
+            raise MockDatabaseError
+          end
         end
       end
       assert_not error.message.include?("SELECT")
@@ -31,8 +33,10 @@ module ActiveRecord
       sql = Book.where(author_id: 96, cover: "hard").to_sql
       binds = [Minitest::Mock.new, Minitest::Mock.new]
       error = assert_raises(ActiveRecord::StatementInvalid) do
-        Book.connection.send(:log, sql, Book.name, binds) do
-          raise MockDatabaseError
+        Book.lease_connection.send(:log, sql, Book.name, binds) do
+          Book.lease_connection.send(:with_raw_connection) do
+            raise MockDatabaseError
+          end
         end
       end
       assert_equal error.sql, sql

data/test/cases/store_test.rb

@@ -3,6 +3,8 @@
 require "cases/helper"
 require "models/admin"
 require "models/admin/user"
+require "models/admin/user_json"
+require "models/account"
 
 class StoreTest < ActiveRecord::TestCase
   fixtures :'admin/users'
@@ -29,6 +31,12 @@ class StoreTest < ActiveRecord::TestCase
     assert_equal "37signals.com", @john.homepage
   end
 
+  test "writing store attributes does not update unchanged value" do
+    admin_user = Admin::User.new(homepage: nil)
+    admin_user.homepage = nil
+    assert_equal({}, admin_user.settings)
+  end
+
   test "reading store attributes through accessors with prefix" do
     assert_equal "Quinn", @john.parent_name
     assert_nil @john.parent_birthday
@@ -81,7 +89,7 @@ class StoreTest < ActiveRecord::TestCase
 
   test "updating the store will mark accessor as changed" do
     @john.color = "red"
-    assert @john.color_changed?
+    assert_predicate @john, :color_changed?
   end
 
   test "new record and no accessors changes" do
@@ -91,17 +99,25 @@ class StoreTest < ActiveRecord::TestCase
     assert_nil user.color_change
 
     user.color = "red"
-    assert user.color_changed?
+    assert_predicate user, :color_changed?
     assert_nil user.color_was
     assert_equal "red", user.color_change[1]
   end
 
   test "updating the store won't mark accessor as changed if the whole store was updated" do
     @john.settings = { color: @john.color, some: "thing" }
-    assert @john.settings_changed?
+    assert_predicate @john, :settings_changed?
     assert_not @john.color_changed?
   end
 
+  test "updating the store and changing it back won't mark accessor as changed" do
+    @john.color = "red"
+    assert_equal "black", @john.color_was
+    @john.color = "black"
+    assert_not_predicate @john, :settings_changed?
+    assert_not_predicate @john, :color_changed?
+  end
+
   test "updating the store populates the accessor changed array correctly" do
     @john.color = "red"
     assert_equal "black", @john.color_was
@@ -117,36 +133,53 @@ class StoreTest < ActiveRecord::TestCase
   test "nullifying the store mark accessor as changed" do
     color = @john.color
     @john.settings = nil
-    assert @john.color_changed?
+    assert_predicate @john, :color_changed?
     assert_equal color, @john.color_was
     assert_equal [color, nil], @john.color_change
   end
 
   test "dirty methods for suffixed accessors" do
     @john.configs[:two_factor_auth] = true
-    assert @john.two_factor_auth_configs_changed?
+    assert_predicate @john, :two_factor_auth_configs_changed?
     assert_nil @john.two_factor_auth_configs_was
     assert_equal [nil, true], @john.two_factor_auth_configs_change
   end
 
   test "dirty methods for prefixed accessors" do
     @john.spouse[:name] = "Lena"
-    assert @john.partner_name_changed?
+    assert_predicate @john, :partner_name_changed?
     assert_equal "Dallas", @john.partner_name_was
     assert_equal ["Dallas", "Lena"], @john.partner_name_change
   end
 
   test "saved changes tracking for accessors" do
     @john.spouse[:name] = "Lena"
-    assert @john.partner_name_changed?
+    assert_predicate @john, :partner_name_changed?
 
     @john.save!
     assert_not @john.partner_name_change
-    assert @john.saved_change_to_partner_name?
+    assert_predicate @john, :saved_change_to_partner_name?
     assert_equal ["Dallas", "Lena"], @john.saved_change_to_partner_name
     assert_equal "Dallas", @john.partner_name_before_last_save
   end
 
+  test "saved changes tracking for accessors with json column" do
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter) && ActiveRecord::Base.lease_connection.mariadb?
+      skip "MariaDB doesn't support JSON store_accessor"
+    end
+    @john.enable_friend_requests = true
+    assert_predicate @john, :enable_friend_requests_changed?
+
+    @john.save!
+    assert_not @john.enable_friend_requests_change
+    assert_predicate @john, :saved_change_to_enable_friend_requests?
+    assert_equal [nil, true], @john.saved_change_to_enable_friend_requests
+    # Make a second change to test key_before_last_save
+    @john.enable_friend_requests = false
+    @john.save
+    assert_equal true, @john.enable_friend_requests_before_last_save
+  end
+
   test "object initialization with not nullable column" do
     assert_equal true, @john.remember_login
   end
@@ -178,7 +211,24 @@ class StoreTest < ActiveRecord::TestCase
     assert_equal "heavy", @john.json_data["weight"]
   end
 
-  test "convert store attributes from Hash to HashWithIndifferentAccess saving the data and access attributes indifferently" do
+  test "serialize stored nested attributes" do
+    user = Admin::User.find_by_name("Jamis")
+    user.update(settings: { "color" => { "jenny" => "blue" }, homepage: "rails" })
+
+    assert_equal true, user.settings.instance_of?(ActiveSupport::HashWithIndifferentAccess)
+    assert_equal "blue", user.settings[:color][:jenny]
+    assert_equal "blue", user.color[:jenny]
+  end
+
+  test "store takes precedence when updating store and accessor" do
+    user = Admin::User.find_by_name("Jamis")
+    user.update(settings: { homepage: "rails" }, homepage: "not rails")
+
+    assert_equal "rails", user.settings[:homepage]
+    assert_equal "rails", user.homepage
+  end
+
+  def test_convert_store_attributes_from_Hash_to_HashWithIndifferentAccess_saving_the_data_and_access_attributes_indifferently
     user = Admin::User.find_by_name("Jamis")
     assert_equal "symbol",  user.settings[:symbol]
     assert_equal "symbol",  user.settings["symbol"]
@@ -317,4 +367,18 @@ class StoreTest < ActiveRecord::TestCase
   test "prefix/suffix do not affect stored attributes" do
     assert_equal [:secret_question, :two_factor_auth, :login_retry], Admin::User.stored_attributes[:configs]
   end
+
+  test "store_accessor raises an exception if the column is not either serializable or a structured type" do
+    user = Class.new(Admin::User) do
+      store_accessor :name, :color
+    end.new
+
+    assert_raises ActiveRecord::ConfigurationError do
+      user.color
+    end
+
+    assert_raises ActiveRecord::ConfigurationError do
+      user.color = "blue"
+    end
+  end
 end