second_level_cache 2.5.3 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57109a059ebed4c9d448fa28e474f19eef4ebf7b67e4ebbd728f2be852b61480
-  data.tar.gz: '049303d75a982adf35dfea344af63577dd9df1c09a28613bb4dec4332ef95de4'
+  metadata.gz: b6cfa929a72e1977223e5fc958b58ead3b3fa81daccbf38d4efe7e4ffc1d608d
+  data.tar.gz: 5709808afb6c5ee8d5937e1ce944005b528c4550e30d0db08b067864a5984d83
 SHA512:
-  metadata.gz: 553a34ea48e7b3100ae819282c354ee0eb51e2d609b7c090bf477035b975a0e497158ca6f4b282add76c882fa7e94277fb39486aaf4e45c35c9e98088a2bbb34
-  data.tar.gz: 28a7f7ea7f32467e92097824559fbaebaf3d9dd0fe49443d7779e666cce3270f3378c8e77dae91bffbc5248c8fadd10f00a08ebbbe390641fa9e42007b917ba5
+  metadata.gz: ee4e3935b1cf774fe00e1432878ffee6104ad5b15c5ad4d6994521b9d5bb7fa183fcbdd97ba3dfd509317f7cd30ebabc0b5f89c18c0dd7aaad028474ef3f7d74
+  data.tar.gz: 173d12fbd5b5b440e37f9d219f9229f0146751debd5c8fa18e54b684ea257ec81a707a46a5b1e39309f9b7bb07784c921ea6a2737d3a681bb7480c9bb8ca6ebf

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+2.6.0
+-------
+
+- Add has_one through cache support. (#98)
+- Fix string query, eager_load, includes/preload for fetch from db. ( #103, #102, #101)
+- Fix preloader if exists default scope. (#104)
+- Change cache hit log as `DEBUG` level. (#105)
+
 2.5.3
 -------
 

data/lib/second_level_cache/active_record.rb

@@ -23,5 +23,5 @@ ActiveSupport.on_load(:active_record) do
   ActiveRecord::Relation.send(:prepend, SecondLevelCache::ActiveRecord::FinderMethods)
   # Rails 5.2 has removed ActiveRecord::Associations::Preloader::BelongsTo
   # https://github.com/rails/rails/pull/31079
-  ActiveRecord::Associations::Preloader::Association.send(:prepend, SecondLevelCache::ActiveRecord::Associations::Preloader::BelongsTo)
+  ActiveRecord::Associations::Preloader::Association.send(:prepend, SecondLevelCache::ActiveRecord::Associations::Preloader)
 end

data/lib/second_level_cache/active_record/fetch_by_uniq_key.rb

@@ -14,7 +14,7 @@ module SecondLevelCache
                      nil
                    end
         end
-        return record if compare_record_attributes_with_where_values(record, where_values)
+        return record if record_attributes_equal_where_values?(record, where_values)
         record = where(where_values).first
         if record
           SecondLevelCache.cache_store.write(cache_key, record.id)
@@ -53,21 +53,9 @@ module SecondLevelCache
         "uniq_key_#{name}_#{ext_key}"
       end
 
-      def compare_record_attributes_with_where_values(record, where_values)
-        return false unless record
-        where_values.all? do |k, v|
-          attribute_value = record.read_attribute(k)
-          attribute_value == case attribute_value
-                             when String
-                               v.to_s
-                             when Numeric
-                               v.to_f
-                             when Date
-                               v.to_date
-                             else # Maybe NilClass/?
-                               v
-                             end
-        end
+      def record_attributes_equal_where_values?(record, where_values)
+        # https://api.rubyonrails.org/classes/ActiveRecord/ModelSchema/ClassMethods.html#method-i-type_for_attribute
+        where_values.all? { |k, v| record&.read_attribute(k) == type_for_attribute(k).cast(v) }
       end
     end
   end

data/lib/second_level_cache/active_record/finder_methods.rb

@@ -17,20 +17,13 @@ module SecondLevelCache
       #     Article.where("articles.user_id = 1").find(prams[:id])
       #     Article.where("user_id = 1 AND ...").find(params[:id])
       def find_one(id)
-        return super(id) unless second_level_cache_enabled?
-        return super(id) unless select_all_column?
+        return super unless cachable?
 
         id = id.id if ActiveRecord::Base == id
-        if cachable?
-          record = @klass.read_second_level_cache(id)
-          if record
-            if where_values_hash.blank? || where_values_match_cache?(record)
-              return record
-            end
-          end
-        end
+        record = @klass.read_second_level_cache(id)
+        return record if record && where_values_match_cache?(record)
 
-        record = super(id)
+        record = super
         record.write_second_level_cache
         record
       end
@@ -48,15 +41,16 @@ module SecondLevelCache
       #     User.where(age: 18).first
       #
       def first(limit = nil)
-        return super(limit) if limit.to_i > 1
+        return super if limit.to_i > 1
+        return super unless cachable?
         # only have primary_key condition in where
         if where_values_hash.length == 1 && where_values_hash.key?(primary_key)
           record = @klass.read_second_level_cache(where_values_hash[primary_key])
           return record if record
         end
 
-        record = super(limit)
-        record&.write_second_level_cache if select_all_column?
+        record = super
+        record&.write_second_level_cache
         record
       end
 
@@ -64,18 +58,31 @@ module SecondLevelCache
 
       # readonly_value - active_record/relation/query_methods.rb Rails 5.1 true/false
       def cachable?
-        limit_one? &&
-          order_values.blank? &&
+        second_level_cache_enabled? &&
+          limit_one? &&
+          # !eager_loading? &&
           includes_values.blank? &&
           preload_values.blank? &&
+          eager_load_values.blank? &&
+          select_values.blank? &&
+          order_values_can_cache? &&
           readonly_value.blank? &&
           joins_values.blank? &&
           !@klass.locking_enabled? &&
-          where_clause_match_equality?
+          where_clause_predicates_all_equality?
+      end
+
+      def order_values_can_cache?
+        return true if order_values.empty?
+        return false unless order_values.one?
+        return true if order_values.first == klass.primary_key
+        return false unless order_values.first.is_a?(::Arel::Nodes::Ordering)
+        return true if order_values.first.expr == klass.primary_key
+        order_values.first.expr.try(:name) == klass.primary_key
       end
 
-      def where_clause_match_equality?
-        where_values_hash.all?
+      def where_clause_predicates_all_equality?
+        where_clause.send(:predicates).size == where_values_hash.size
       end
 
       def where_values_match_cache?(record)
@@ -91,10 +98,6 @@ module SecondLevelCache
       def limit_one?
         limit_value.blank? || limit_value == 1
       end
-
-      def select_all_column?
-        select_values.blank?
-      end
     end
   end
 end

data/lib/second_level_cache/active_record/has_one_association.rb

@@ -6,31 +6,25 @@ module SecondLevelCache
       module HasOneAssociation
         def find_target
           return super unless klass.second_level_cache_enabled?
-          return super if reflection.options[:through] || reflection.scope
-          # TODO: implement cache with has_one through, scope
+          return super if reflection.scope
+          # TODO: implement cache with has_one scope
 
-          owner_primary_key = owner[reflection.active_record_primary_key]
-          if reflection.options[:as]
-            keys = {
-              reflection.foreign_key => owner_primary_key,
-              reflection.type => owner.class.base_class.name
-            }
-            cache_record = klass.fetch_by_uniq_keys(keys)
-          else
-            cache_record = klass.fetch_by_uniq_key(owner_primary_key, reflection.foreign_key)
-          end
+          through = reflection.options[:through]
+          record  = if through
+                      return super unless klass.reflections[through.to_s].klass.second_level_cache_enabled?
+                      begin
+                        reflection.klass.find(owner.send(through).read_attribute(reflection.foreign_key))
+                      rescue StandardError
+                        nil
+                      end
+                    else
+                      uniq_keys = { reflection.foreign_key => owner[reflection.active_record_primary_key] }
+                      uniq_keys[reflection.type] = owner.class.base_class.name if reflection.options[:as]
+                      klass.fetch_by_uniq_keys(uniq_keys)
+                    end
 
-          if cache_record
-            return cache_record.tap { |record| set_inverse_instance(record) }
-          end
-
-          record = super
           return nil unless record
-
-          record.tap do |r|
-            set_inverse_instance(r)
-            r.write_second_level_cache
-          end
+          record.tap { |r| set_inverse_instance(r) }
         end
       end
     end

data/lib/second_level_cache/active_record/preloader.rb

@@ -3,41 +3,47 @@
 module SecondLevelCache
   module ActiveRecord
     module Associations
-      class Preloader
-        module BelongsTo
-          def records_for(ids, &block)
-            return super(ids, &block) unless reflection.is_a?(::ActiveRecord::Reflection::BelongsToReflection)
-            return super(ids, &block) unless klass.second_level_cache_enabled?
-
-            map_cache_keys = ids.map { |id| klass.second_level_cache_key(id) }
-            records_from_cache = ::SecondLevelCache.cache_store.read_multi(*map_cache_keys)
-            # NOTICE
-            # Rails.cache.read_multi return hash that has keys only hitted.
-            # eg. Rails.cache.read_multi(1,2,3) => {2 => hit_value, 3 => hit_value}
-            hitted_ids = records_from_cache.map { |key, _| key.split("/")[2] }
-            missed_ids = ids.map(&:to_s) - hitted_ids
-
-            ::SecondLevelCache.logger.info "missed ids -> #{missed_ids.join(',')} | hitted ids -> #{hitted_ids.join(',')}"
-
-            record_marshals = RecordMarshal.load_multi(records_from_cache.values)
-
-            if missed_ids.empty?
-              return SecondLevelCache::RecordRelation.new(record_marshals)
-            end
-
-            records_from_db = super(missed_ids, &block)
-            records_from_db.map do |r|
-              write_cache(r)
-            end
-
-            SecondLevelCache::RecordRelation.new(records_from_db + record_marshals)
-          end
+      module Preloader
+        RAILS6 = ::ActiveRecord.version >= ::Gem::Version.new("6")
+
+        def records_for(ids, &block)
+          return super unless klass.second_level_cache_enabled?
+          return super unless reflection.is_a?(::ActiveRecord::Reflection::BelongsToReflection)
+          return super if klass.default_scopes.present?
+
+          map_cache_keys = ids.map { |id| klass.second_level_cache_key(id) }
+          records_from_cache = ::SecondLevelCache.cache_store.read_multi(*map_cache_keys)
+
+          record_marshals = if RAILS6
+                              RecordMarshal.load_multi(records_from_cache.values) do |record|
+                                # This block is copy from:
+                                # https://github.com/rails/rails/blob/6-0-stable/activerecord/lib/active_record/associations/preloader/association.rb#L101
+                                owner = owners_by_key[convert_key(record[association_key_name])].first
+                                association = owner.association(reflection.name)
+                                association.set_inverse_instance(record)
+                              end
+                            else
+                              RecordMarshal.load_multi(records_from_cache.values, &block)
+                            end
+
+          # NOTICE
+          # Rails.cache.read_multi return hash that has keys only hitted.
+          # eg. Rails.cache.read_multi(1,2,3) => {2 => hit_value, 3 => hit_value}
+          hitted_ids = record_marshals.map { |record| record.read_attribute(association_key_name).to_s }
+          missed_ids = ids.map(&:to_s) - hitted_ids
+          ::SecondLevelCache.logger.debug("missed #{association_key_name} -> #{missed_ids.join(',')} | hitted #{association_key_name} -> #{hitted_ids.join(',')}")
+          return SecondLevelCache::RecordRelation.new(record_marshals) if missed_ids.empty?
+
+          records_from_db = super(missed_ids, &block)
+          records_from_db.map { |r| write_cache(r) }
+
+          SecondLevelCache::RecordRelation.new(records_from_db + record_marshals)
+        end
 
-          private
+        private
 
-          def write_cache(record)
-            record.write_second_level_cache
-          end
+        def write_cache(record)
+          record.write_second_level_cache
         end
       end
     end

data/lib/second_level_cache/mixin.rb

@@ -76,18 +76,8 @@ module SecondLevelCache
 
       marshal = RecordMarshal.dump(self)
       expires_in = klass.second_level_cache_options[:expires_in]
-      expire_changed_association_uniq_keys
       SecondLevelCache.cache_store.write(second_level_cache_key, marshal, expires_in: expires_in)
     end
-
     alias update_second_level_cache write_second_level_cache
-
-    def expire_changed_association_uniq_keys
-      reflections = klass.reflections.select { |_, reflection| reflection.belongs_to? }
-      changed_keys = reflections.map { |_, reflection| reflection.foreign_key } & previous_changes.keys
-      changed_keys.each do |key|
-        SecondLevelCache.cache_store.delete(klass.send(:cache_uniq_key, key => previous_changes[key][0]))
-      end
-    end
   end
 end

data/lib/second_level_cache/record_marshal.rb

@@ -2,54 +2,21 @@
 
 module RecordMarshal
   class << self
-    # dump ActiveRecord instace with only attributes.
-    # ["User",
-    #  {"id"=>30,
-    #  "email"=>"dddssddd@gmail.com",
-    #  "created_at"=>2012-07-25 18:25:57 UTC
-    #  }
-    # ]
-
+    # dump ActiveRecord instance with only attributes before type cast.
     def dump(record)
-      [record.class.name, record.attributes]
+      [record.class.name, record.attributes_before_type_cast]
     end
 
     # load a cached record
-    def load(serialized)
+    def load(serialized, &block)
       return unless serialized
-      # fix issues 19
-      # fix 2.1.2 object.changed? ActiveRecord::SerializationTypeMismatch: Attribute was supposed to be a Hash, but was a String. -- "{:a=>\"t\", :b=>\"x\"}"
-      # fix 2.1.4 object.changed? is true
-      # fix Rails 4.2 is deprecating `serialized_attributes` without replacement to Rails 5 is deprecating `serialized_attributes` without replacement
-      klass = serialized[0].constantize
-      attributes = serialized[1]
-
-      # for ActiveRecord 5.0.0
-      klass.columns.each do |c|
-        name = c.name
-        cast_type = klass.attribute_types[name]
-        next unless cast_type.is_a?(::ActiveRecord::Type::Serialized)
-        coder = cast_type.coder
-        next if attributes[name].nil? || attributes[name].is_a?(String)
-        if coder.is_a?(::ActiveRecord::Coders::YAMLColumn)
-          attributes[name] = coder.dump(attributes[name]) if attributes[name].is_a?(coder.object_class)
-        elsif coder.is_a?(::ActiveRecord::Store::IndifferentCoder)
-          # https://github.com/rails/rails/blob/5b14129/activerecord/lib/active_record/store.rb#L179
-          attributes[name] = coder.dump(attributes[name])
-        elsif coder == ::ActiveRecord::Coders::JSON
-          attributes[name] = attributes[name].to_json
-        end
-      end
-
-      klass.defined_enums.each do |key, value|
-        attributes[key] = value[attributes[key]] if attributes[key].is_a?(String)
-      end
 
-      klass.instantiate(attributes)
+      serialized[0].constantize.instantiate(serialized[1], &block)
     end
 
-    def load_multi(serializeds)
-      serializeds.map { |serialized| load(serialized) }
+    # load multi cached records
+    def load_multi(serializeds, &block)
+      serializeds.map { |serialized| load(serialized, &block) }
     end
   end
 end

data/lib/second_level_cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SecondLevelCache
-  VERSION = "2.5.3"
+  VERSION = "2.6.0"
 end

data/test/fetch_by_uniq_key_test.rb

@@ -17,15 +17,18 @@ class FetchByUinqKeyTest < ActiveSupport::TestCase
     assert Contribution.send(:cache_uniq_key, user_id: 1, date: Time.current.to_date), "uniq_key_Contribution_user_id_1,date_#{Time.current.to_date}"
   end
 
-  def test_compare_record_attributes_with_where_values
-    book = Book.new(title: "foobar")
-    assert Book.send(:compare_record_attributes_with_where_values, book, title: :foobar)
-    book.discount_percentage = 60.00
-    assert Book.send(:compare_record_attributes_with_where_values, book, discount_percentage: "60")
-    book.publish_date = Time.current.to_date
-    assert Book.send(:compare_record_attributes_with_where_values, book, publish_date: Time.current.to_date.to_s)
-    book.title = nil
-    assert Book.send(:compare_record_attributes_with_where_values, book, title: nil)
+  def test_record_attributes_equal_where_values
+    book = Book.new
+    assert_no_queries do
+      book.title = "foobar"
+      assert Book.send(:record_attributes_equal_where_values?, book, title: :foobar)
+      book.discount_percentage = 60.00
+      assert Book.send(:record_attributes_equal_where_values?, book, discount_percentage: "60")
+      book.publish_date = Time.current.to_date
+      assert Book.send(:record_attributes_equal_where_values?, book, publish_date: Time.current.to_date.to_s)
+      book.title = nil
+      assert Book.send(:record_attributes_equal_where_values?, book, title: nil)
+    end
   end
 
   def test_should_query_from_db_using_primary_key

data/test/finder_methods_test.rb

@@ -59,6 +59,45 @@ class FinderMethodsTest < ActiveSupport::TestCase
     refute_equal @user.name, @from_db.name
   end
 
+  def test_should_fetch_from_db_if_where_use_string
+    @user.write_second_level_cache
+    assert_queries(:any) do
+      assert_nil User.unscoped.where(id: @user.id).where("name = 'nonexistent'").first
+    end
+    assert_queries(:any) do
+      assert_raises ActiveRecord::RecordNotFound do
+        User.where("name = 'nonexistent'").find(@user.id)
+      end
+    end
+  end
+
+  def test_should_fetch_from_db_when_use_eager_load
+    @user.write_second_level_cache
+    assert_queries(:any) do
+      assert_sql(/LEFT\sOUTER\sJOIN\s\"books\"/m) do
+        User.eager_load(:books).find(@user.id)
+      end
+    end
+  end
+
+  def test_should_fetch_from_db_when_use_includes
+    @user.write_second_level_cache
+    assert_queries(:any) do
+      assert_sql(/SELECT\s\"books\"\.\*\sFROM\s\"books\"/m) do
+        User.includes(:books).find(@user.id)
+      end
+    end
+  end
+
+  def test_should_fetch_from_db_when_use_preload
+    @user.write_second_level_cache
+    assert_queries(:any) do
+      assert_sql(/SELECT\s\"books\"\.\*\sFROM\s\"books\"/m) do
+        User.preload(:books).find(@user.id)
+      end
+    end
+  end
+
   def test_where_and_first_should_with_cache
     @user.write_second_level_cache
     assert_no_queries do

data/test/has_one_association_test.rb

@@ -20,10 +20,16 @@ class HasOneAssociationTest < ActiveSupport::TestCase
     clean_user = user.reload
     assert_equal User, clean_user.forked_from_user.class
     assert_equal @user.id, user.forked_from_user.id
-    # clean_user = user.reload
-    # assert_no_queries do
-    #   clean_user.forked_from_user
-    # end
+    # If ForkedUserLink second_level_cache_enabled is true
+    user.reload
+    assert_no_queries do
+      user.forked_from_user
+    end
+    # IF ForkedUserLink second_level_cache_enabled is false
+    user.reload
+    ForkedUserLink.without_second_level_cache do
+      assert_queries(1) { user.forked_from_user }
+    end
   end
 
   def test_has_one_with_conditions
@@ -49,4 +55,10 @@ class HasOneAssociationTest < ActiveSupport::TestCase
     @account.update(user_id: @user.id + 1)
     assert_nil @user.reload.account
   end
+
+  def test_should_one_query_when_has_one_target_is_null
+    Namespace.destroy_all
+    @user.reload
+    assert_queries(1) { @user.namespace }
+  end
 end

data/test/model/account.rb

@@ -9,5 +9,5 @@ end
 
 class Account < ActiveRecord::Base
   second_level_cache expires_in: 3.days
-  belongs_to :user
+  belongs_to :user, foreign_key: :user_id, inverse_of: :account
 end

data/test/model/book.rb

@@ -7,11 +7,14 @@ ActiveRecord::Base.connection.create_table(:books, force: true) do |t|
   t.decimal :discount_percentage, precision: 5, scale: 2
   t.integer :images_count, default: 0
   t.date    :publish_date
+  t.boolean :normal, default: true, nil: false
 end
 
 class Book < ActiveRecord::Base
   second_level_cache
 
+  default_scope -> { where(normal: true) }
+
   belongs_to :user, counter_cache: true
   has_many :images, as: :imagable
 end

data/test/model/user.rb

@@ -10,7 +10,7 @@ ActiveRecord::Base.connection.create_table(:users, force: true) do |t|
   t.integer :books_count, default: 0
   t.integer :images_count, default: 0
   t.datetime :deleted_at
-  t.timestamps null: false
+  t.timestamps null: false, precision: 6
 end
 
 ActiveRecord::Base.connection.create_table(:forked_user_links, force: true) do |t|
@@ -35,7 +35,7 @@ class User < ActiveRecord::Base
   serialize :json_options, JSON if ::ActiveRecord::VERSION::STRING >= "4.1.0"
   store :extras, accessors: %i[tagline gender]
 
-  has_one  :account
+  has_one  :account, inverse_of: :user
   has_one  :forked_user_link, foreign_key: "forked_to_user_id"
   has_one  :forked_from_user, through: :forked_user_link
   has_many :namespaces
@@ -53,6 +53,8 @@ class Namespace < ActiveRecord::Base
 end
 
 class ForkedUserLink < ActiveRecord::Base
+  second_level_cache version: 1, expires_in: 1.day
+
   belongs_to :forked_from_user, class_name: "User"
   belongs_to :forked_to_user, class_name: "User"
 end

data/test/{preloader_test.rb → preloader_belongs_to_test.rb}

@@ -2,8 +2,8 @@
 
 require "test_helper"
 
-class PreloaderTest < ActiveSupport::TestCase
-  def test_belongs_to_preload_caches_includes
+class PreloaderBelongsToTest < ActiveSupport::TestCase
+  def test_preload_caches_includes
     topics = [
       Topic.create(title: "title1", body: "body1"),
       Topic.create(title: "title2", body: "body2"),
@@ -18,7 +18,7 @@ class PreloaderTest < ActiveSupport::TestCase
     assert_equal topics, results.map(&:topic)
   end
 
-  def test_belongs_to_when_read_multi_missed_from_cache_ar_will_fetch_missed_records_from_db
+  def test_when_read_multi_missed_from_cache_ar_will_fetch_missed_records_from_db
     topics = [
       Topic.create(title: "title1", body: "body1"),
       Topic.create(title: "title2", body: "body2"),
@@ -39,19 +39,21 @@ class PreloaderTest < ActiveSupport::TestCase
     assert_equal topics, results.map(&:topic)
   end
 
-  def test_has_many_preloader_returns_correct_results
-    topic = Topic.create(id: 1)
-    Post.create(id: 1)
-    post = topic.posts.create
-
-    assert_equal [post], Topic.includes(:posts).find(1).posts
+  def test_preloader_caches_includes_tried_set_inverse_instance
+    user_id = Time.current.to_i
+    Account.create(site: "foobar", user_id: user_id)
+    User.create(id: user_id, name: "foobar", email: "foobar@test.com")
+    accounts = Account.includes(:user)
+    assert_equal accounts.first.object_id, accounts.first.user.account.object_id
   end
 
-  def test_has_one_preloader_returns_correct_results
-    user = User.create(id: 1)
-    Account.create(id: 1)
-    account = user.create_account
-
-    assert_equal account, User.includes(:account).find(1).account
+  def test_preloader_from_db_when_exists_scope
+    user = User.create
+    book = user.books.create
+    image = book.images.create
+    book.toggle!(:normal)
+    assert_queries(:any) do
+      assert_nil Image.includes(:imagable).where(id: image.id).first.imagable
+    end
   end
 end

data/test/preloader_has_many_test.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class PreloaderHasManyTest < ActiveSupport::TestCase
+  def test_preloader_returns_correct_records
+    topic = Topic.create(id: 1)
+    Post.create(id: 1)
+    post = topic.posts.create
+
+    assert_equal [post], Topic.includes(:posts).find(1).posts
+  end
+end

data/test/preloader_has_one_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class PreloaderHasOneTest < ActiveSupport::TestCase
+  # def test_preload_caches_includes
+  #   users = User.create([
+  #                         { name: "foobar1", email: "foobar1@test.com" },
+  #                         { name: "foobar2", email: "foobar2@test.com" },
+  #                         { name: "foobar3", email: "foobar3@test.com" }
+  #                       ])
+  #   namespaces = users.map { |user| user.create_namespace(name: user.name) }
+
+  #   assert_queries(2) { User.includes(:namespace).order(id: :asc).to_a }  # Write cache
+  #   assert_queries(1) do
+  #     assert_equal namespaces, User.includes(:namespace).order(id: :asc).map(&:namespace)
+  #   end
+  # end
+
+  # def test_when_read_multi_missed_from_cache_should_will_fetch_missed_records_from_db
+  #   users = User.create([
+  #                         { name: "foobar1", email: "foobar1@test.com" },
+  #                         { name: "foobar2", email: "foobar2@test.com" },
+  #                         { name: "foobar3", email: "foobar3@test.com" }
+  #                       ])
+  #   namespaces = users.map { |user| user.create_namespace(name: user.name) }
+  #   assert_queries(2) { User.includes(:namespace).order(id: :asc).to_a }  # Write cache
+  #   expired_namespace = namespaces.first
+  #   expired_namespace.expire_second_level_cache
+
+  #   assert_queries(2) do
+  #     assert_sql(/WHERE\s\"namespaces\".\"kind\"\sIS\sNULL\sAND\s\"namespaces\"\.\"user_id\"\s=\s?/m) do
+  #       results = User.includes(:namespace).order(id: :asc).to_a
+  #       assert_equal namespaces, results.map(&:namespace)
+  #       assert_equal expired_namespace, results.first.namespace
+  #     end
+  #   end
+  # end
+
+  # def test_preloader_returns_correct_records_after_modify
+  #   user = User.create(name: "foobar", email: "foobar@test.com")
+
+  #   old_namespace = user.create_namespace(name: "old")
+  #   assert_queries(2) { User.includes(:namespace).order(id: :asc).to_a }  # Write cache
+  #   assert_queries(1) do
+  #     assert_equal old_namespace, User.includes(:namespace).first.namespace
+  #   end
+
+  #   new_namespace = user.create_namespace(name: "new")
+  #   assert_queries(2) { User.includes(:namespace).order(id: :asc).to_a }  # Write cache
+  #   assert_queries(1) do
+  #     assert_equal new_namespace, User.includes(:namespace).first.namespace
+  #   end
+  # end
+
+  # def test_preloader_caches_includes_tried_set_inverse_instance
+  #   User.create(name: "foobar", email: "foobar@test.com").create_account(site: "foobar")
+  #   users = User.includes(:account)
+  #   assert_equal users.first.object_id, users.first.account.user.object_id
+  # end
+
+  def test_has_one_preloader_returns_correct_results
+    user = User.create(id: 1)
+    Account.create(id: 1)
+    account = user.create_account
+
+    assert_equal account, User.includes(:account).find(1).account
+  end
+end

data/test/record_marshal_test.rb

@@ -25,7 +25,7 @@ class RecordMarshalTest < ActiveSupport::TestCase
     dumped = RecordMarshal.dump(@user)
     assert dumped.is_a?(Array)
     assert_equal "User", dumped[0]
-    assert_equal @user.attributes, dumped[1]
+    assert_equal dumped[1], ActiveRecord::Base.connection.select_all(User.where(id: @user.id)).first
   end
 
   def test_should_load_active_record_object

data/test/test_helper.rb

@@ -33,7 +33,7 @@ SecondLevelCache.configure do |config|
   config.cache_store = ActiveSupport::Cache::MemoryStore.new
 end
 
-SecondLevelCache.logger.level = Logger::ERROR
+SecondLevelCache.logger.level = Logger::INFO
 ActiveSupport::Cache::MemoryStore.logger = SecondLevelCache.logger
 ActiveRecord::Base.logger = SecondLevelCache.logger
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: second_level_cache
 version: !ruby/object:Gem::Version
-  version: 2.5.3
+  version: 2.6.0
 platform: ruby
 authors:
 - Hooopo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-26 00:00:00.000000000 Z
+date: 2020-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -153,8 +153,10 @@ files:
 - test/model/user.rb
 - test/persistence_test.rb
 - test/polymorphic_association_test.rb
+- test/preloader_belongs_to_test.rb
+- test/preloader_has_many_test.rb
+- test/preloader_has_one_test.rb
 - test/preloader_non_integer_test.rb
-- test/preloader_test.rb
 - test/record_marshal_test.rb
 - test/require_test.rb
 - test/second_level_cache_test.rb
@@ -188,15 +190,17 @@ summary: 'SecondLevelCache is a write-through and read-through caching library i
   is a cache miss, it will populate the cache.  Write-Through: As objects are created,
   updated, and deleted, all of the caches are automatically kept up-to-date and coherent.'
 test_files:
+- test/preloader_belongs_to_test.rb
 - test/polymorphic_association_test.rb
 - test/require_test.rb
-- test/preloader_test.rb
 - test/finder_methods_test.rb
+- test/preloader_has_one_test.rb
 - test/preloader_non_integer_test.rb
 - test/belongs_to_association_test.rb
 - test/second_level_cache_test.rb
 - test/enum_attr_test.rb
 - test/record_marshal_test.rb
+- test/preloader_has_many_test.rb
 - test/persistence_test.rb
 - test/single_table_inheritance_test.rb
 - test/model/image.rb