with_model 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bac7bd2d2e529887f1e9bd82117cc809f23b336a8acaa2b90e4fb9305c96fe2
-  data.tar.gz: 1867b36f42957d744858fcefe70f53c58b0c5f39b951a4749a969c39c46b42f0
+  metadata.gz: f788d32a4cd252a5254b82928cab9b62b66cfd80e00dd010bdb901b60a6ddc6c
+  data.tar.gz: 2c44d64d8f3225e809c113894ec77df2e64c6dae513a12065e171bd892c80c7d
 SHA512:
-  metadata.gz: eec34fe045c932273600775ccf7b2719dad1d10d6631baf43b9b7d54eec50bc4592d24cc1da1e9af7a844e7fbc73f707a0027d9f58c891afd18fb934e1f796d9
-  data.tar.gz: 5720ad24f60c91dee5b1eac354a0ca3d3f00d6c65e5d2f45fc76a310d6330564f43ec14924f168edc064121e9cc70b4ca7483c08a33587ea90f20031fff3fba2
+  metadata.gz: bbf514f03d362582bf15cd38301a9f2929c559ea702c283bae2c01720f48e3f613e93ce1580906983d567048d7241d70af92b94f54f4d992da06f3497c9afc8e
+  data.tar.gz: 66200b79760795f6d3e622b4b29c13285fb042e4e168f1fea34ac38161bca41e4330a451add6f9a0db777dd20cbde97567cd687c811dff1675a1090a24dc7704

data/.github/workflows/ci.yml

@@ -29,8 +29,6 @@ jobs:
       matrix:
         ruby-version: ["3.3", "3.4", "4.0"]
         active-record:
-          - label: AR 7.2
-            env: ACTIVE_RECORD_VERSION=~> 7.2.0
           - label: AR 8.0
             env: ACTIVE_RECORD_VERSION=~> 8.0.0
           - label: AR 8.1
@@ -52,11 +50,6 @@ jobs:
               label: AR 8-0-stable
               env: ACTIVE_RECORD_BRANCH=8-0-stable
             allow-failure: true
-          - ruby-version: "4.0"
-            active-record:
-              label: AR 7-2-stable
-              env: ACTIVE_RECORD_BRANCH=7-2-stable
-            allow-failure: true
           # A canary for the next Ruby, which cannot fail the build.
           - ruby-version: ruby-head
             active-record:
@@ -78,11 +71,6 @@ jobs:
           ruby-version: ${{ matrix.ruby-version }}
           bundler-cache: true
           cache-version: ${{ matrix.active-record.env }}
-      # Gemfile.lock is not checked in, so this resolves the newest gems that
-      # satisfy the Gemfile on each run rather than a recorded set. `--all` is
-      # what Bundler 4, shipped with Ruby 4.0, wants for that.
-      - name: Update bundle
-        run: bundle update --all
       # Not bin/rake: bin/ holds generated binstubs and is not checked in, and
       # whether bundling writes them there varies by Bundler version - Bundler 4
       # does not, which left Ruby 4.0 with no binstub to run.

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+### Unreleased
+
+### 2.4.0
+
+- Add Test::Unit support, including lifecycle integration for dynamic models and
+  tables.
+- Add `with_model/rspec`, `with_model/minitest`, and `with_model/test_unit`
+  convenience entrypoints.
+- Add runner integration guides for RSpec, Minitest, and Test::Unit.
+- Skip temporary-table teardown when the table has already disappeared.
+- Require Active Record 8.0 or later.
+
+### 2.3.1
+
+- Honor Active Record destruction callbacks and dependent associations when
+  cleaning up rows for a `table(false)` model.
+
 ### 2.3.0
 
 - Add `table(false)` to create no table, so that a model whose superclass is a

data/CONTRIBUTING.md

@@ -24,12 +24,22 @@ avoid anything that only works on the newest of either.
 
 ## Running the tests
 
-The suite runs against both supported test harnesses, so `with_model` has to work
-under each:
+The suite runs against all three supported test harnesses, so `with_model` has
+to work under each:
 
 - `spec/` covers behavior under RSpec.
-- `test/` covers the minitest life cycle — the setup and teardown hooks, and
+- `test/` covers the Minitest life cycle — the setup and teardown hooks, and
   their ordering — rather than repeating the specs.
+- `test_unit/` covers Test::Unit integration in a dedicated process, including
+  native fixture callback ordering.
+
+Run one harness with its scoped Rake task:
+
+```sh
+bundle exec rake spec
+bundle exec rake test
+bundle exec rake test_unit
+```
 
 Run everything, including the linter, with:
 
@@ -37,6 +47,13 @@ Run everything, including the linter, with:
 bundle exec rake
 ```
 
+Validate the README and runner guides with RDoc before submitting documentation
+changes:
+
+```sh
+rm -rf tmp/rdoc && bundle exec rdoc --markup markdown --op tmp/rdoc README.md docs/rspec.md docs/minitest.md docs/test-unit.md lib/**/*.rb
+```
+
 `bin/` holds generated binstubs and is not checked in. Whether bundling writes
 them for you depends on your Bundler version, so create them once if you would
 rather type `bin/rake`:

data/Gemfile

@@ -24,3 +24,4 @@ gem "rspec"
 gem "ruby-lsp"
 gem "sqlite3"
 gem "standard"
+gem "test-unit"

data/README.md

@@ -14,32 +14,63 @@
 
 Install as usual: `gem install with_model` or add `gem 'with_model'` to your Gemfile. See [`.github/workflows/ci.yml`](./.github/workflows/ci.yml) for supported (tested) Ruby versions.
 
+## Test runner setup
+
+Choose the entrypoint for the test runner that owns the declarations. Each
+performs complete global setup for one runner; see its guide for lifecycle and
+manual-setup details.
+
 ### RSpec
 
-Extend `WithModel` into RSpec:
+```ruby
+require "with_model/rspec"
+```
+
+See the [RSpec guide](docs/rspec.md).
+
+### Minitest
 
 ```ruby
-require "with_model"
+require "with_model/minitest"
+```
 
-RSpec.configure do |config|
-  config.extend WithModel
-end
+See the [Minitest guide](docs/minitest.md).
+
+### Test::Unit
+
+```ruby
+require "with_model/test_unit"
 ```
 
-### minitest/spec
+See the [Test::Unit guide](docs/test-unit.md).
 
-Extend `WithModel` into minitest/spec and set the test runner explicitly:
+### Advanced and mixed-runner setup
+
+Plain `require "with_model"` remains framework-neutral. For manual setup,
+select a runner and extend its test context directly:
 
 ```ruby
+require "minitest"
 require "with_model"
 
 WithModel.runner = :minitest
+Minitest::Test.extend WithModel
+```
 
-class Minitest::Spec
-  extend WithModel
+RSpec uses `RSpec.configure { |config| config.extend WithModel }`; Test::Unit
+uses `Test::Unit::TestCase.extend WithModel`. A declaration can override the
+global runner when needed:
+
+```ruby
+with_model :Post, runner: :test_unit do
+  table
 end
 ```
 
+Loading multiple convenience entrypoints in one process is unsupported because
+the last one changes the global runner. For mixed runners, use plain
+`with_model`, direct extension, and explicit `runner:` options.
+
 ## Usage
 
 After setting up as above, call `with_model` and inside its block pass it a `table` block and a `model` block.
@@ -252,7 +283,13 @@ the order they are declared, and destroyed in the reverse order.
 
 ## Requirements
 
-See the [gemspec metadata](https://rubygems.org/gems/with_model) for dependency requirements. RSpec and minitest are indirect dependencies, and `with_model` should support any maintained version of both.
+See the [gemspec metadata](https://rubygems.org/gems/with_model) for Ruby and
+Active Record requirements. RSpec, Minitest, and Test::Unit are optional
+consumer framework dependencies; install the framework used by its selected
+entrypoint. Requiring a selected entrypoint without its framework installed
+raises the framework's ordinary `LoadError`.
+
+`scope:` is RSpec-only and is silently ignored by Minitest and Test::Unit.
 
 ## Thread-safety
 

data/Rakefile

@@ -8,7 +8,13 @@ RSpec::Core::RakeTask.new
 require "minitest/test_task"
 Minitest::TestTask.create
 
+require "rake/testtask"
+Rake::TestTask.new(:test_unit) do |task|
+  task.libs << "lib" << "test_unit" << "test"
+  task.pattern = "test_unit/**/*_test.rb"
+end
+
 # standard rake task
 require "standard/rake"
 
-task default: %i[spec test standard]
+task default: %i[spec test test_unit standard]

data/docs/minitest.md

@@ -0,0 +1,45 @@
+# Minitest integration
+
+Load the Minitest entrypoint before defining tests:
+
+```ruby
+require "with_model/minitest"
+```
+
+This requires `minitest`, then `with_model`, selects the
+`:minitest` runner, and extends `Minitest::Test`. Its class-level DSL is
+inherited by `Minitest::Test` subclasses, including `Minitest::Spec` and
+`ActiveSupport::TestCase`. The entrypoint does not require or start Minitest's
+autorun — your process or test framework owns Minitest startup.
+
+## Lifecycle
+
+The Minitest runner creates declared models and tables in `before_setup` and
+destroys them in `after_teardown`. This makes them available to ordinary setup
+methods and keeps them available through teardown. `scope:` is silently ignored
+by Minitest because it is an RSpec-only option.
+
+## Manual setup
+
+If another process or tool owns Minitest configuration, configure manually:
+
+```ruby
+require "minitest"
+require "with_model"
+
+WithModel.runner = :minitest
+Minitest::Test.extend WithModel
+```
+
+Minitest is an optional consumer dependency. Requiring `with_model/minitest`
+without Minitest installed raises Minitest's ordinary `LoadError`.
+
+## Mixed runners
+
+Do not load multiple convenience entrypoints in one process: each changes the
+global runner, and the last one wins. For mixed runners, load plain
+`with_model`, extend each framework boundary directly, and select a runner per
+declaration with `runner:`.
+
+See the [general DSL reference](../README.md#usage) for declaring models and
+tables.

data/docs/rspec.md

@@ -0,0 +1,43 @@
+# RSpec integration
+
+Load the RSpec entrypoint before defining example groups:
+
+```ruby
+require "with_model/rspec"
+```
+
+The entrypoint requires `rspec/core` and `with_model`, selects the `:rspec`
+runner, and extends RSpec example groups through `RSpec.configure`. It does not
+start RSpec; the RSpec command-line runner remains in control.
+
+## Lifecycle
+
+`with_model` and `with_table` register RSpec `before` and `after` hooks. Models
+and tables are available to examples after setup and are removed after cleanup.
+Use `scope:` when RSpec hook scope is needed, including `scope: :all` for a
+model needed by `before(:all)`. `scope:` is an RSpec-only option.
+
+## Manual setup
+
+For runner-owned setup, require the framework and `with_model` separately:
+
+```ruby
+require "rspec/core"
+require "with_model"
+
+WithModel.runner = :rspec
+RSpec.configure { |config| config.extend WithModel }
+```
+
+RSpec is an optional consumer dependency. Requiring `with_model/rspec` without
+RSpec installed raises RSpec's ordinary `LoadError`.
+
+## Mixed runners
+
+Do not load multiple convenience entrypoints in one process: each changes the
+global runner, and the last one wins. For mixed runners, load plain
+`with_model`, extend each framework boundary directly, and select a runner per
+declaration with `runner:`.
+
+See the [general DSL reference](../README.md#usage) for declaring models and
+tables.

data/docs/test-unit.md

@@ -0,0 +1,73 @@
+# Test::Unit integration
+
+Load the Test::Unit entrypoint before defining tests:
+
+```ruby
+require "with_model/test_unit"
+```
+
+The entrypoint requires `test/unit`, then `with_model`, selects the
+`:test_unit` runner, and extends `Test::Unit::TestCase`. Test::Unit retains
+ownership of autorun and fixture execution.
+
+## Lifecycle
+
+`with_model` and `with_table` register Test::Unit fixture callbacks with exact
+placement: setup uses `before: :append`, while teardown uses `after: :prepend`.
+Declared models and tables therefore create in declaration order before user or
+inherited setup methods and callbacks. They destroy in reverse order after user
+or inherited teardown methods and callbacks.
+
+Test::Unit runs teardown when setup raises. `WithModel::Model#destroy`
+defensively handles creation that never assigned a model. `Table#destroy` checks
+whether its table exists before dropping it, so teardown does not raise solely
+because a reconnect replaced an in-memory database or the table otherwise
+already disappeared. It does not rescue other database, connection, or drop
+errors; those still propagate. This conditional drop check does not promise
+generic partial-creation recovery for bare `with_table`. `scope:` is silently
+ignored by Test::Unit because it is an RSpec-only option.
+
+## Errata and concerns
+
+Establish the Active Record connection before `with_model`'s setup callback
+creates tables and models. An ordinary `def setup` runs too late. Connect in
+your test helper before test classes load, or register a connection callback
+with `setup(before: :prepend)`.
+
+```ruby
+class PostTest < Test::Unit::TestCase
+  setup(before: :prepend) do
+    ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+  end
+
+  with_model :Post do
+    table
+  end
+end
+```
+
+## Manual setup
+
+For runner-owned setup, require Test::Unit and `with_model` separately:
+
+```ruby
+require "test/unit"
+require "with_model"
+
+WithModel.runner = :test_unit
+Test::Unit::TestCase.extend WithModel
+```
+
+Test::Unit is an optional consumer dependency. Requiring
+`with_model/test_unit` without Test::Unit installed raises Test::Unit's ordinary
+`LoadError`.
+
+## Mixed runners
+
+Do not load multiple convenience entrypoints in one process: each changes the
+global runner, and the last one wins. For mixed runners, load plain
+`with_model`, extend each framework boundary directly, and select a runner per
+declaration with `runner:`.
+
+See the [general DSL reference](../README.md#usage) for declaring models and
+tables.

data/lib/with_model/descendants_tracker.rb

@@ -74,14 +74,6 @@ module WithModel
   end
 end
 
-class ActiveRecord::Base
-  extend WithModel::DescendantsTracker::DestroyedClassesFiltering
-end
-
-module ActiveSupport
-  module DescendantsTracker
-    class << self
-      attr_reader :clear_disabled
-    end
-  end
-end
+ActiveRecord::Base.singleton_class.prepend(
+  WithModel::DescendantsTracker::DestroyedClassesFiltering
+)

data/lib/with_model/minitest.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "with_model"
+
+WithModel.runner = :minitest
+Minitest::Test.extend WithModel

data/lib/with_model/model.rb

@@ -74,8 +74,6 @@ module WithModel
       # can only do so while the class still has its name.
       table.teardown(@model)
       stubber.unstub_const
-      cleanup_descendants_tracking
-      reset_dependencies_cache
       WithModel::DescendantsTracker.clear([@model])
       @model = nil
     end
@@ -132,17 +130,6 @@ module WithModel
       @model.reset_column_information
     end
 
-    def cleanup_descendants_tracking
-      ActiveSupport::DescendantsTracker.clear([@model]) \
-        unless ActiveSupport::DescendantsTracker.clear_disabled
-    end
-
-    def reset_dependencies_cache
-      return unless defined?(ActiveSupport::Dependencies::Reference)
-
-      ActiveSupport::Dependencies::Reference.clear!
-    end
-
     def stubber
       @stubber ||= ConstantStubber.new const_name
     end

data/lib/with_model/null_table.rb

@@ -13,17 +13,17 @@ module WithModel
   class NullTable
     # @param [Class] superclass The resolved superclass whose table will be
     #   inherited.
-    # @param [Symbol, String] name The model's name, so that a refusal can say
+    # @param [Symbol, String] name The model's name, so that an error can say
     #   which model it is talking about.
     def initialize(superclass, name)
       @superclass = superclass
       @name = name
     end
 
-    # Creates nothing, but refuses a superclass that cannot support single
-    # table inheritance.
+    # Creates nothing, but raises {WithModel::InvalidSuperclass} when the
+    # superclass cannot support single table inheritance.
     #
-    # Refusals describe the model's situation rather than the call that produced
+    # Errors describe the model's situation rather than the call that produced
     # it. Any expression that evaluates to false selects a NullTable, so there
     # is no call spelling to quote - and in with_model 3.0, omitting `table`
     # will arrive here too.
@@ -31,20 +31,20 @@ module WithModel
     # A superclass whose table does not exist *yet* is deliberately allowed: the
     # table may be created later in the example, and a test may legitimately
     # want a model whose table is missing. Active Record raises a clear
-    # `StatementInvalid` naming the table if it never appears, so refusing here
+    # `StatementInvalid` naming the table if it never appears, so raising here
     # would only forbid working setups.
     #
-    # What is left is {WithModel::InvalidSuperclass}: both refusals are permanent
+    # What is left is {WithModel::InvalidSuperclass}: both errors are permanent
     # facts about the superclass passed in, not about when it was looked at, so no
     # amount of waiting makes them work.
     def create
-      refuse "#{@superclass} has none to inherit" unless table_name?
+      raise_invalid_superclass "#{@superclass} has none to inherit" unless table_name?
 
       # Nothing more can be checked until there is a table to look at.
       return unless table_exists?
       return if inheritance_column?
 
-      refuse "#{@superclass}'s table #{@superclass.table_name.inspect} has no " \
+      raise_invalid_superclass "#{@superclass}'s table #{@superclass.table_name.inspect} has no " \
              "#{inheritance_column.inspect} column, so Active Record cannot tell its rows " \
              "apart from a subclass's"
     end
@@ -59,7 +59,7 @@ module WithModel
     # (`ActiveRecord::SubclassNotFound`).
     #
     # `unscoped` is required because a `default_scope` on the superclass would
-    # otherwise hide rows from the delete; the inheritance-column condition is
+    # otherwise hide rows from cleanup; the inheritance-column condition is
     # then reapplied explicitly, since `unscoped` also discards the type
     # condition that keeps this from touching the superclass's own rows.
     #
@@ -68,7 +68,7 @@ module WithModel
     def teardown(klass)
       return unless klass.table_exists?
 
-      klass.unscoped.where(klass.inheritance_column => klass.sti_name).delete_all
+      klass.unscoped.where(klass.inheritance_column => klass.sti_name).each(&:destroy!)
     end
 
     # Drops nothing; there is no table of our own to drop.
@@ -90,7 +90,7 @@ module WithModel
       inheritance_column.present? && @superclass.columns_hash.key?(inheritance_column)
     end
 
-    def refuse(problem)
+    def raise_invalid_superclass(problem)
       raise InvalidSuperclass,
         "with_model #{@name.inspect} has no table of its own, but #{problem}"
     end

data/lib/with_model/rspec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "with_model"
+
+WithModel.runner = :rspec
+
+RSpec.configure do |config|
+  config.extend WithModel
+end

data/lib/with_model/table.rb

@@ -38,19 +38,13 @@ module WithModel
     end
 
     def destroy
-      connection.drop_table(@name)
+      connection.drop_table(@name) if exists?
     end
 
     private
 
     attr_reader :connection
 
-    def exists?
-      if connection.respond_to?(:data_source_exists?)
-        connection.data_source_exists?(@name)
-      else
-        connection.table_exists?(@name)
-      end
-    end
+    def exists? = connection.data_source_exists?(@name)
   end
 end

data/lib/with_model/test_unit.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "test/unit"
+require "with_model"
+
+WithModel.runner = :test_unit
+Test::Unit::TestCase.extend WithModel

data/lib/with_model/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WithModel
-  VERSION = "2.3.0"
+  VERSION = "2.4.0"
 end

data/lib/with_model.rb

@@ -113,8 +113,13 @@ module WithModel
       class_eval do
         include MiniTestLifeCycle.call(object)
       end
+    when :test_unit
+      # These options place creation before and destruction after user callbacks,
+      # preserving declaration and reverse order across inheritance.
+      setup(before: :append) { object.create }
+      teardown(after: :prepend) { object.destroy }
     else
-      raise ArgumentError, "Unsupported test runner set, expected :rspec or :minitest"
+      raise ArgumentError, "Unsupported test runner set, expected :rspec, :minitest, or :test_unit"
     end
   end
 end

data/spec/descendants_tracking_spec.rb

@@ -30,7 +30,6 @@ describe "Descendants tracking" do
 
   context "with ActiveSupport::DescendantsTracker (cache_classes: true)" do
     before do
-      expect(ActiveSupport::DescendantsTracker.clear_disabled).to be_falsey
       expect { ActiveSupport::DescendantsTracker.clear([]) }.not_to raise_exception
     end
 
@@ -40,10 +39,29 @@ describe "Descendants tracking" do
   context "without ActiveSupport::DescendantsTracker (cache_classes: false)" do
     before do
       ActiveSupport::DescendantsTracker.disable_clear!
-      expect(ActiveSupport::DescendantsTracker.clear_disabled).to be_truthy
       expect { ActiveSupport::DescendantsTracker.clear([]) }.to raise_exception(RuntimeError)
     end
 
     include_examples "clearing descendants between test runs"
   end
+
+  it "keeps filtering ahead of later class method extensions" do
+    raw_subclasses = Class.instance_method(:subclasses).super_method
+    raw_descendants = Class.instance_method(:descendants).super_method
+    override = Module.new do
+      define_method(:subclasses) { raw_subclasses.bind_call(self) }
+      define_method(:descendants) { raw_descendants.bind_call(self) }
+    end
+    destroyed_model = stub_const("DestroyedModel", Class.new(ActiveRecord::Base))
+    WithModel::DescendantsTracker.clear([destroyed_model])
+
+    ActiveRecord::Base.extend override
+
+    expect(ActiveRecord::Base.descendants).not_to include(destroyed_model)
+  ensure
+    override&.module_eval do
+      remove_method :subclasses
+      remove_method :descendants
+    end
+  end
 end