custom_counter_cache 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b86370bc27fe59b1bafc3f2160e69843c9650e58b6c9e980010eb5f88fb229cd
-  data.tar.gz: 0aeccd374cf039a73f248fa4440f3d472859f73f83b4a0f991b432eaba7bf10e
+  metadata.gz: c9162e152f23f2e1bcbe16bc8eac89109fb42e3710f056e280ffc7e2509972ea
+  data.tar.gz: 48a92f691a0d60be81222f930ee511cf7cc5af62b90a2d6dbb940d2bd6c40e83
 SHA512:
-  metadata.gz: f0de231b5e888db121d43d3a37909e37b8e3cb1fd4bf0c58ad0195bda8030f4937a1aba70729716c6c23f3ec1aa48888f68308bb998d6e50fe8bcb71529d9bde
-  data.tar.gz: 721794ae2b6cb35349209392f390d42352d3f0fa31a10599b7c13e7dd98e00bdba7c29c96ccfd9033d99e4c508aeab845ec2db9e653bd93f21238fb899892d12
+  metadata.gz: a5140b21c810447e0f8593b57252ef42064cecfc26168a46df39fa2f813f042e54aabb32c602f275c6ead13f30fc4c05b929db0cb2ffbb557367be1a4b628ef9
+  data.tar.gz: 8a0101a516d27d8b076d97173fa1733b6d4b53f85877448229c30afaa60ea78bb7059fda11e41602de505148497f79a36622bb394f968340f8947fc788b68725

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+## 0.3.2
+
+### Fixed
+
+- Moving a record between owners now recounts the old owner when `belongs_to` uses a custom
+  `primary_key:`.
+- Polymorphic `belongs_to` with custom `foreign_key:`/`foreign_type:` no longer raises
+  `NoMethodError` on save.
+- Moving a record away from a polymorphic type whose class no longer exists no longer raises
+  `NameError`; the new owner is still recounted.
+- With `includes(:counters)`, counters stay current after an update, and a missing counter
+  returns 0 without a query.
+- Two saves creating the same virtual counter at once no longer fail with
+  `ActiveRecord::RecordNotUnique`; the second updates the row instead.
+- `update_counter_cache` without its `belongs_to` raises a clear `ArgumentError` instead of
+  `NoMethodError ... for nil`.
+
+### Changed
+
+- Depend on `activerecord` and `activesupport` instead of all of `rails`.
+- Require Ruby >= 3.1 in the gemspec, matching the README and Rails 7.2.
+- Test against every non-EOL Ruby (3.3, 3.4, 4.0) and Rails (8.0, 8.1).
+- Expand the test suite to cover all branches.
+- README: fix the `:if` example (`state_changed?` is always false in after callbacks)
+  and note that `:if` also applies to `after_destroy`.

data/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2011-2026 Cedric Howe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,87 @@
+{rdoc-image:https://github.com/cedric/custom_counter_cache/actions/workflows/ci.yml/badge.svg}[https://github.com/cedric/custom_counter_cache/actions/workflows/ci.yml]
+
+== Custom Counter Cache
+
+This is a simple approach to creating a custom counter cache in Rails that can be used across multiple models.
+
+=== Requirements
+
+* Ruby >= 3.1
+* Rails (Active Record) >= 7.2
+
+CI covers the Ruby and Rails versions that are not yet end-of-life.
+
+=== Installation
+
+Add the following to your Gemfile:
+
+  gem 'custom_counter_cache'
+
+=== Example
+
+== Class with counter cache
+
+This is the block that will be used to calculate the value for the counter cache. It will be called by other models through their association via an after_save or after_destroy callback.
+
+  include CustomCounterCache::Model
+  define_counter_cache :articles_count do |user|
+    user.articles.where(state: 'published').count
+  end
+
+== Class with callbacks
+
+This will define the after_create, after_update and after_destroy callbacks. An :if option can be provided to limit when these callbacks get triggered.
+
+  include CustomCounterCache::Model
+  update_counter_cache :user, :articles_count, if: -> (article) { article.destroyed? || article.saved_change_to_state? }
+
+The callbacks run after the record is saved, so use <tt>saved_change_to_state?</tt> rather than
+<tt>state_changed?</tt> (which is always false by then). The :if condition also applies to
+after_destroy, where there are no saved changes, hence the <tt>destroyed?</tt> check.
+
+Other options: <tt>:unless</tt>, <tt>:only</tt> / <tt>:except</tt> (e.g. <tt>only: [:create, :destroy]</tt>)
+and <tt>:prepend</tt>.
+
+These callbacks can be added to any number of models that might need to change the counter cache.
+
+== Counter Cache
+
+To store the counter cache you need to create a column for the model with the counter cache (example: articles_count).
+
+If you would like to store all of your counter caches in a single table, you can use this migration:
+
+  create_table :counters do |t|
+    t.references :countable, polymorphic: true
+    t.string :key, null: false
+    t.integer :value, null: false, default: 0
+    t.timestamps
+  end
+  add_index :counters, [ :countable_id, :countable_type, :key ], unique: true
+
+Here is the example model to go with:
+
+  class Counter < ActiveRecord::Base
+    belongs_to :countable, polymorphic: true
+    validates :countable, presence: true
+  end
+
+Note: do not add <tt>dependent: :destroy</tt> to that +belongs_to+. On a
++belongs_to+, <tt>dependent: :destroy</tt> means "when this Counter is
+destroyed, also destroy the record it belongs to" -- the opposite of what you
+want, and it creates a destroy loop: destroying a countable record cascades
+into destroying its Counters (via the <tt>has_many :counters, dependent:
+:delete_all</tt> this gem defines), and a wrongly-configured +belongs_to+ would
+then cascade back into destroying the same countable record again. The
+countable side's <tt>dependent: :delete_all</tt> already handles cleanup and
+skips Counter's own callbacks entirely, so no +dependent+ option belongs on
+the +belongs_to+ side at all.
+
+If you would like to store your counter cache in an existing table, you can use this migration:
+
+  def change
+    add_column :users, :articles_count, :integer, default: 0, null: false
+  end
+
+To backfill your counters, run something like this either in a migration or in the console:
+
+  User.select(:id).find_each(batch_size: 100) { |u| u.update_articles_count }

data/lib/custom_counter_cache/model.rb

@@ -9,24 +9,30 @@ module CustomCounterCache::Model
 
       # counter accessors
       unless column_names.include?(cache_column.to_s)
-        # Only declare the :counters association once per class -- a model
-        # can have multiple virtual (non-column) counter caches, and
-        # redeclaring has_many :counters for each one just redefines the
-        # same reader/writer methods again, which Ruby warns about under -w.
+        # Declare once per class: redeclaring for each virtual counter triggers method-redefinition warnings.
         has_many :counters, as: :countable, dependent: :delete_all unless reflect_on_association(:counters)
         define_method "#{cache_column}" do
-          # check if the counter is loaded
-          if counters.loaded? && counter = counters.detect{|c| c.key == cache_column.to_s }
-            counter.value
+          # Once loaded (e.g. includes(:counters)), a missing row means 0, not a query.
+          if counters.loaded?
+            counters.detect { |c| c.key == cache_column.to_s }.try(:value).to_i
           else
             counters.find_by(key: cache_column.to_s).try(:value).to_i
           end
         end
         define_method "#{cache_column}=" do |count|
-          if ( counter = counters.find_by(key: cache_column.to_s) )
+          # Update the loaded Counter itself, or the reader keeps returning its stale value.
+          counter = counters.loaded? ? counters.detect { |c| c.key == cache_column.to_s } : counters.find_by(key: cache_column.to_s)
+          if counter
             counter.update_attribute :value, count.to_i
           else
-            counters.create key: cache_column.to_s, value: count.to_i
+            begin
+              # Savepoint: on PostgreSQL a failed INSERT would otherwise abort the caller's whole transaction.
+              self.class.transaction(requires_new: true) { counters.create key: cache_column.to_s, value: count.to_i }
+            rescue ActiveRecord::RecordNotUnique
+              # Lost a create race. A locking read sees the winner's row even under REPEATABLE READ (MySQL).
+              counters.reset
+              counters.lock.find_by!(key: cache_column.to_s).update_attribute :value, count.to_i
+            end
           end
         end
       end
@@ -52,25 +58,28 @@ module CustomCounterCache::Model
       cache_column = cache_column.to_sym
       method_name  = "callback_#{association}_#{cache_column}".to_sym
       reflection   = reflect_on_association(association)
-      foreign_key  = reflection.try(:foreign_key) || reflection.association_foreign_key
+      raise ArgumentError, "#{self} must declare belongs_to :#{association} before update_counter_cache" unless reflection
+      foreign_key  = reflection.foreign_key
 
       # define callback
       define_method method_name do
         # update old association
-        if reflection.options[:polymorphic]
-          type_key = "#{association}_type"
-          id_key   = "#{association}_id"
-          if send("saved_change_to_#{id_key}?") || send("saved_change_to_#{type_key}?")
-            old_type = send("saved_change_to_#{type_key}?") ? send("#{type_key}_before_last_save") : send(type_key)
-            old_id   = send("saved_change_to_#{id_key}?")   ? send("#{id_key}_before_last_save")   : send(id_key)
-            if ( old_type && old_id && record = old_type.constantize.find_by(id: old_id) )
+        if reflection.polymorphic?
+          type_key = reflection.foreign_type
+          id_key   = foreign_key
+          if saved_change_to_attribute?(id_key) || saved_change_to_attribute?(type_key)
+            old_type = saved_change_to_attribute?(type_key) ? attribute_before_last_save(type_key) : self[type_key]
+            old_id   = saved_change_to_attribute?(id_key)   ? attribute_before_last_save(id_key)   : self[id_key]
+            # safe_: the stored type may name a class that has since been renamed or removed.
+            old_klass = old_type&.safe_constantize
+            if ( old_klass && old_id && record = old_klass.find_by(reflection.association_primary_key(old_klass) => old_id) )
               record.send("update_#{cache_column}")
             end
           end
         else
-          if send("saved_change_to_#{foreign_key}?")
-            old_id = send("#{foreign_key}_before_last_save")
-            if ( old_id && record = reflection.klass.find_by(id: old_id) )
+          if saved_change_to_attribute?(foreign_key)
+            old_id = attribute_before_last_save(foreign_key)
+            if ( old_id && record = reflection.klass.find_by(reflection.association_primary_key => old_id) )
               record.send("update_#{cache_column}")
             end
           end

data/lib/custom_counter_cache/version.rb

@@ -1,5 +1,5 @@
 module CustomCounterCache
 
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 
 end

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: custom_counter_cache
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Cedric Howe
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -30,6 +29,60 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -44,22 +97,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-description: ''
+description: Define counter caches computed by an arbitrary block (e.g. a scoped count),
+  refreshed by callbacks on any number of associated models, and stored in a column
+  or a shared polymorphic counters table.
 email: cedric@howe.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE
+- README.rdoc
 - lib/custom_counter_cache.rb
 - lib/custom_counter_cache/model.rb
 - lib/custom_counter_cache/version.rb
-- test/counter_test.rb
-- test/test_helper.rb
-homepage: http://github.com/cedric/custom_counter_cache/
+homepage: https://github.com/cedric/custom_counter_cache
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  source_code_uri: https://github.com/cedric/custom_counter_cache
+  changelog_uri: https://github.com/cedric/custom_counter_cache/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -67,18 +124,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.6
+      version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.21
 specification_version: 4
 summary: Custom counter_cache functionality that supports conditions and multiple
   models.
-test_files:
-- test/counter_test.rb
-- test/test_helper.rb
+test_files: []

data/test/counter_test.rb

@@ -1,282 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class CounterTest < Minitest::Test
-
-  def setup
-    @user = User.create
-    @box = Box.create
-    Counter.destroy_all
-  end
-
-  def test_default_counter_value
-    assert_equal 0, @user.published_count
-    assert_equal 0, @box.green_balls_count
-  end
-
-  def test_create_and_destroy_counter
-    @user.articles.create(state: 'published')
-    assert_equal 1, Counter.count
-    @user.destroy
-    assert_equal 0, Counter.count
-  end
-
-  def test_create_and_destroy_polymorphic_association_counter
-    @article = @user.articles.create(state: "published")
-    assert_equal 0, @article.comments.size
-    @comment = @article.comments.create(state: "published")
-    assert_equal 1, @article.comments.size
-    @article.destroy
-    assert_equal 0, @article.comments.size
-  end
-
-  def test_increment_and_decrement_counter_with_conditions
-    @article = @user.articles.create(state: 'unpublished')
-    assert_equal 0, @user.published_count
-    @article.update_attribute :state, 'published'
-    assert_equal 1, @user.published_count
-    3.times { |i| @user.articles.create(state: 'published') }
-    assert_equal 4, @user.published_count
-    @user.articles.each {|a| a.update(state: 'unpublished') }
-    assert_equal 0, @user.published_count
-  end
-
-  def test_increment_and_decrement_polymorphic_counter_with_conditions
-    @article = @user.articles.create(state: "published")
-    @comment = @article.comments.create(state: "unpublished")
-    assert_equal 0, @article.comments_count
-    @comment.update_attribute :state, "published"
-    assert_equal 1, @article.comments_count
-    3.times { |i| @article.comments.create(state: "published") }
-    assert_equal 4, @article.comments_count
-    @article.comments.each { |c| c.update(state: 'unpublished') }
-    assert_equal 0, @article.comments_count
-  end
-
-  def test_increment_and_decrement_counter_with_conditions_on_model_with_counter_column
-    @ball = @box.balls.create(color: 'red')
-    assert_equal 0, @box.reload.green_balls_count
-    @ball.update_attribute :color, 'green'
-    assert_equal 1, @box.reload.green_balls_count
-    3.times { |i| @box.balls.create(color: 'green') }
-    assert_equal 4, @box.reload.green_balls_count
-    @box.balls.each {|b| b.update(color: 'red') }
-    assert_equal 0, @box.reload.green_balls_count
-  end
-
-  # Test that an eager loaded
-  def test_eager_loading_with_no_counter
-    @article = @user.articles.create(state: 'unpublished')
-    user = User.includes(:counters).first
-    assert_equal 0, user.published_count
-
-  end
-
-  def test_eager_loading_with_counter
-    @article = @user.articles.create(state: 'published')
-    @user = User.includes(:counters).find(@user.id)
-    assert_equal 1, @user.published_count
-  end
-
-  def test_except_option
-    @ball = @box.balls.create
-    assert_equal 1, @box.reload.lifetime_balls_count
-    @ball.update(color: 'green')
-    assert_equal 1, @box.reload.lifetime_balls_count
-    @ball.destroy
-    assert_equal 1, @box.reload.lifetime_balls_count
-  end
-
-  def test_only_option
-    @ball = @box.balls.create
-    assert_equal 0, @box.reload.destroyed_balls_count
-    @ball.update(color: 'green')
-    assert_equal 0, @box.reload.destroyed_balls_count
-    @ball.destroy
-    assert_equal 1, @box.reload.destroyed_balls_count
-  end
-
-  def test_reassigning_article_to_different_user_updates_both_counters
-    @user2 = User.create
-    @article = @user.articles.create(state: 'unpublished')
-    assert_equal 0, @user.reload.published_count
-    assert_equal 0, @user2.reload.published_count
-    # Changing both user and state triggers the :if condition (state changed)
-    # and the reassignment logic inside the callback updates the old user's counter too
-    @article.update(user: @user2, state: 'published')
-    assert_equal 0, @user.reload.published_count
-    assert_equal 1, @user2.reload.published_count
-  end
-
-  # -- destroy loop regression --
-  #
-  # A consumer's Counter model might mistakenly add `dependent: :destroy` to
-  # its `belongs_to :countable` (see test_helper.rb's Counter class and the
-  # README "Note" on this). On a belongs_to, dependent: :destroy means "when
-  # I am destroyed, also destroy the record I belong to" -- the opposite of
-  # what a counter cache needs. Combined with the has_many :counters this gem
-  # defines on the countable side, that mistake used to create a destroy
-  # loop: destroying a countable record cascaded into destroying its
-  # Counters, and each Counter's (wrongly configured) belongs_to cascaded
-  # back into destroying the same countable record again, re-running its
-  # full before_destroy chain against already-destroyed associations.
-  #
-  # has_many :counters now uses dependent: :delete_all, which deletes Counter
-  # rows with a single SQL statement and never instantiates them or runs
-  # their callbacks -- so a misconfigured Counter#belongs_to (like the one in
-  # this test suite's fixtures, deliberately) can no longer cause the loop.
-
-  def test_destroying_a_countable_record_with_a_dependent_association_does_not_recurse
-    @user.articles.create!(state: 'published') # gives the user a real Counter row
-    note = UserNote.create!(user: @user)
-
-    @user.destroy!
-
-    assert @user.destroyed?
-    refute UserNote.exists?(note.id)
-  end
-
-  def test_counters_are_removed_via_a_single_delete_without_instantiating_them
-    @user.articles.create!(state: 'published')
-    assert_equal 1, Counter.where(countable: @user).count
-
-    # dependent: :delete_all must never call Counter#destroy -- prove it by
-    # making Counter#destroy raise, then destroying the user anyway.
-    Counter.define_method(:destroy) { raise 'Counter#destroy should not be called' }
-
-    @user.destroy!
-
-    assert_equal 0, Counter.where(countable_type: 'User', countable_id: @user.id).count
-  ensure
-    Counter.send(:remove_method, :destroy) if Counter.instance_methods(false).include?(:destroy)
-  end
-
-  # -- update_counter_cache: polymorphic reassignment --
-  #
-  # For a polymorphic association, the old owner must be looked up by its
-  # old *type* and old *id* together -- either can change independently
-  # (moving to a different record of the same type only changes the id;
-  # moving to a different type changes both).
-
-  def test_reassigning_a_polymorphic_association_updates_both_old_and_new_owner_counters
-    article1 = @user.articles.create!(state: 'unpublished')
-    article2 = @user.articles.create!(state: 'unpublished')
-    comment = article1.comments.create!(state: 'unpublished')
-    comment.update!(state: 'published')
-    assert_equal 1, article1.reload.comments_count
-    assert_equal 0, article2.reload.comments_count
-
-    # The :if condition only fires the callback on a state change, so toggle
-    # state alongside the reassignment -- same pattern as
-    # test_reassigning_article_to_different_user_updates_both_counters above.
-    comment.update!(commentable: article2, state: 'unpublished')
-    comment.update!(state: 'published')
-
-    assert_equal 0, article1.reload.comments_count
-    assert_equal 1, article2.reload.comments_count
-  end
-
-  # -- rescue StandardError / Heroku DATABASE_URL guard --
-  #
-  # Both class methods wrap their body in a rescue that swallows any
-  # StandardError raised while table_exists? can't reach a database (e.g.
-  # during `assets:precompile` on Heroku, where there is no DB connection at
-  # all), but only when DATABASE_URL matches Heroku's placeholder value.
-  # Anywhere else, the error must still propagate.
-
-  def with_stubbed_table_exists(klass, error)
-    klass.define_singleton_method(:table_exists?) { raise error }
-    yield
-  ensure
-    klass.singleton_class.send(:remove_method, :table_exists?)
-  end
-
-  def test_define_counter_cache_reraises_when_database_url_is_not_the_heroku_placeholder
-    klass = Class.new(ApplicationRecord) { self.table_name = 'users' }
-    with_stubbed_table_exists(klass, 'no database connection') do
-      assert_raises(RuntimeError) { klass.define_counter_cache(:whatever) { |r| 0 } }
-    end
-  end
-
-  def test_define_counter_cache_swallows_error_when_database_url_is_the_heroku_placeholder
-    klass = Class.new(ApplicationRecord) { self.table_name = 'users' }
-    with_env('DATABASE_URL', 'postgres://user:pass@127.0.0.1/dbname') do
-      with_stubbed_table_exists(klass, 'no database connection') do
-        klass.define_counter_cache(:whatever) { |r| 0 } # must not raise
-      end
-    end
-    refute klass.method_defined?(:whatever)
-  end
-
-  def test_update_counter_cache_reraises_when_database_url_is_not_the_heroku_placeholder
-    klass = Class.new(ApplicationRecord) { self.table_name = 'articles' }
-    with_stubbed_table_exists(klass, 'no database connection') do
-      assert_raises(RuntimeError) { klass.update_counter_cache(:user, :whatever) }
-    end
-  end
-
-  def test_update_counter_cache_swallows_error_when_database_url_is_the_heroku_placeholder
-    klass = Class.new(ApplicationRecord) { self.table_name = 'articles' }
-    with_env('DATABASE_URL', 'postgres://user:pass@127.0.0.1/dbname') do
-      with_stubbed_table_exists(klass, 'no database connection') do
-        klass.update_counter_cache(:user, :whatever) # must not raise
-      end
-    end
-  end
-
-  def with_env(key, value)
-    original = ENV[key]
-    ENV[key] = value
-    yield
-  ensure
-    ENV[key] = original
-  end
-
-  # -- table_exists? early return (no error, just a missing table) --
-
-  def test_define_counter_cache_is_a_no_op_when_the_table_does_not_exist
-    klass = Class.new(ApplicationRecord) { self.table_name = 'nonexistent_table_xyz' }
-    klass.define_counter_cache(:whatever) { |r| 0 }
-    refute klass.method_defined?(:whatever)
-    refute klass.method_defined?(:update_whatever)
-  end
-
-  def test_update_counter_cache_is_a_no_op_when_the_table_does_not_exist
-    klass = Class.new(ApplicationRecord) { self.table_name = 'nonexistent_table_xyz' }
-    klass.update_counter_cache(:user, :whatever)
-    refute klass.method_defined?(:callback_user_whatever)
-  end
-
-  # -- update_counter_cache: :unless option --
-
-  def test_unless_option_skips_the_callback_when_true
-    @ball = @box.balls.create(color: 'red')
-    assert_equal 1, @box.reload.non_green_balls_count
-    @ball.update(color: 'green')
-    # :unless suppresses the callback here, so the count is stale (still 1)
-    # rather than recomputed to 0 -- proving the callback did not run.
-    assert_equal 1, @box.reload.non_green_balls_count
-  end
-
-  def test_unless_option_runs_the_callback_when_false
-    @ball = @box.balls.create(color: 'green')
-    @ball.update(color: 'red')
-    assert_equal 1, @box.reload.non_green_balls_count
-  end
-
-  # -- update_counter_cache: :prepend option --
-  #
-  # NOTE: this checks that :prepend is forwarded to the after_create callback
-  # chain (the gem's own responsibility), not that it changes visible
-  # execution order -- that's a separate, Rails-internals quirk: plain
-  # sequential after_* callbacks in this Rails version don't necessarily run
-  # in chain order just because one was prepended (confirmed with a bare
-  # `after_create ..., prepend: true` outside this gem entirely).
-
-  def test_prepend_option_is_forwarded_to_the_callback_chain
-    after_create_filters = Ball._create_callbacks.select { |cb| cb.kind == :after }.map(&:filter)
-    assert_operator after_create_filters.index(:callback_box_marker_b_count),
-      :<, after_create_filters.index(:callback_box_marker_a_count),
-      'expected the prepend: true callback (marker_b) to be ordered before the non-prepended one (marker_a)'
-  end
-
-end

data/test/test_helper.rb

@@ -1,138 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require 'sqlite3'
-require 'action_view'
-require 'active_record'
-require 'custom_counter_cache'
-
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-
-ActiveRecord::Schema.define(version: 1) do
-  create_table :users do |t|
-  end
-
-  create_table :articles do |t|
-    t.belongs_to :user
-    t.string :state, default: 'unpublished'
-  end
-
-  create_table :comments do |t|
-    t.belongs_to :user
-    t.references :commentable, polymorphic: true
-    t.string :state, default: "unpublished"
-  end
-
-  create_table :counters do |t|
-    t.references :countable, polymorphic: true
-    t.string :key, null: false
-    t.integer :value, null: false, default: 0
-  end
-  add_index :counters, [ :countable_id, :countable_type, :key ], unique: true
-
-  create_table :boxes do |t|
-    t.integer :green_balls_count, default: 0
-    t.integer :lifetime_balls_count, default: 0
-    t.integer :destroyed_balls_count, default: 0
-  end
-
-  create_table :balls do |t|
-    t.belongs_to :box
-    t.string :color, default: 'red'
-  end
-
-  create_table :user_notes do |t|
-    t.belongs_to :user
-  end
-
-  create_table :user_note_logs do |t|
-    t.belongs_to :user_note
-  end
-end
-
-class ApplicationRecord < ActiveRecord::Base
-  self.abstract_class = true
-  include CustomCounterCache::Model
-end
-
-class User < ApplicationRecord
-  has_many :articles, dependent: :destroy
-  has_one :user_note, dependent: :destroy
-  define_counter_cache :published_count do |user|
-    user.articles.where(articles: { state: 'published' }).count
-  end
-end
-
-class Article < ApplicationRecord
-  belongs_to :user
-  update_counter_cache :user, :published_count, if: Proc.new { |article| article.saved_change_to_attribute?(:state) }
-  has_many :comments, as: :commentable, dependent: :destroy
-  define_counter_cache :comments_count do |article|
-    article.comments.where(state: "published").count
-  end
-end
-
-class Comment < ApplicationRecord
-  belongs_to :commentable, polymorphic: true
-  update_counter_cache :commentable, :comments_count, if: Proc.new { |comment| comment.saved_change_to_attribute?(:state) }
-end
-
-class Counter < ApplicationRecord
-  # Deliberately mirrors a real-world consumer mistake: adding dependent: :destroy
-  # to this belongs_to (see README "Note"). It must NOT cause destroying a
-  # countable record to recurse back into destroying itself a second time --
-  # see DestroyLoopTest, which is what actually guards against this.
-  belongs_to :countable, polymorphic: true, dependent: :destroy
-end
-
-class Box < ApplicationRecord
-  has_many :balls
-  define_counter_cache :green_balls_count do |box|
-    box.balls.green.count
-  end
-  define_counter_cache :lifetime_balls_count do |box|
-    box.lifetime_balls_count + 1
-  end
-  define_counter_cache :destroyed_balls_count do |box|
-    box.destroyed_balls_count + 1
-  end
-  define_counter_cache :non_green_balls_count do |box|
-    box.balls.where.not(color: 'green').count
-  end
-  define_counter_cache :marker_a_count do |box|
-    0
-  end
-  define_counter_cache :marker_b_count do |box|
-    0
-  end
-end
-
-class Ball < ApplicationRecord
-  belongs_to :box
-  scope :green, lambda { where(color: 'green') }
-  update_counter_cache :box, :green_balls_count, if: Proc.new { |ball| ball.saved_change_to_attribute?(:color) }
-  update_counter_cache :box, :lifetime_balls_count, except: [:update, :destroy]
-  update_counter_cache :box, :destroyed_balls_count, only: [:destroy]
-  update_counter_cache :box, :non_green_balls_count, unless: Proc.new { |ball| ball.color == 'green' }
-  update_counter_cache :box, :marker_a_count, only: [:create]
-  update_counter_cache :box, :marker_b_count, only: [:create], prepend: true
-end
-
-# Stands in for something like the `audited` gem: a has_one association whose
-# own destroy writes a dependent log record from a before_destroy callback
-# (matching how `audited` hooks in -- before_destroy, not after_destroy, so
-# the record is still persisted? while the callback runs). If destroying the
-# owner (User) ever recurses back into destroying itself a second time, this
-# fails the second time around because the UserNote is no longer persisted.
-class UserNote < ApplicationRecord
-  belongs_to :user
-  has_many :logs, class_name: 'UserNoteLog', foreign_key: :user_note_id, dependent: :destroy
-  before_destroy :write_log
-
-  def write_log
-    logs.create!
-  end
-end
-
-class UserNoteLog < ApplicationRecord
-  belongs_to :user_note
-end