with_model 2.3.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e161c7fe750e7eb3b78e178a14b2e23ef88b0fa4612abfb22e3920be9eda614e
-  data.tar.gz: fb6d9310626f6a006463782d179406e1a2af10b6672899fb57c2bf26f6df61a0
+  metadata.gz: f788d32a4cd252a5254b82928cab9b62b66cfd80e00dd010bdb901b60a6ddc6c
+  data.tar.gz: 2c44d64d8f3225e809c113894ec77df2e64c6dae513a12065e171bd892c80c7d
 SHA512:
-  metadata.gz: 7d80585ba48b4b87593f9b7f18b8c4674391e51458b5e273ee121e4962bf4b479000a178a83db14cfa38a1eb185c8f09ac01d727ce6f79afe39ce5e45686ca70
-  data.tar.gz: 3e241e4d17f7b5d889e665e5cb17e5d66de1ca7fdd3b3cbd4e73615421561f735aa3d3f40176b27c1be32cfc9e1db7059d642662ad35fc786fc45620b8a8146f
+  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,5 +1,15 @@
 ### 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

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/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.1"
+  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

data/spec/runner_entrypoints_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "open3"
+require "rbconfig"
+require "tmpdir"
+
+RSpec.describe "runner integration entrypoints" do
+  def run_ruby(source, load_paths: ["lib"])
+    Open3.capture3(
+      RbConfig.ruby,
+      *load_paths.map { |path| "-I#{path}" },
+      "-e",
+      source
+    )
+  end
+
+  def expect_native_runner_to_pass(source, load_paths: ["lib"])
+    stdout, stderr, status = run_ruby(source, load_paths:)
+
+    expect(status).to be_success, <<~MESSAGE
+      subprocess failed with status #{status.exitstatus}
+      stdout:
+      #{stdout}
+      stderr:
+      #{stderr}
+    MESSAGE
+  end
+
+  it "configures RSpec and extends new example groups" do
+    expect_native_runner_to_pass(<<~'RUBY')
+      require "with_model/rspec"
+      abort "runner: #{WithModel.runner.inspect}" unless WithModel.runner == :rspec
+
+      RSpec.describe "entrypoint" do
+        it "installs the DSL" do
+          expect(self.class).to respond_to(:with_model)
+        end
+      end
+
+      exit RSpec::Core::Runner.run([])
+    RUBY
+  end
+
+  it "configures Minitest and extends new test subclasses" do
+    expect_native_runner_to_pass(<<~'RUBY')
+      require "with_model/minitest"
+      abort "runner: #{WithModel.runner.inspect}" unless WithModel.runner == :minitest
+
+      # Assert that minitest/autorun is not loaded
+      autorun_loaded = $LOADED_FEATURES.any? { |f| f.end_with?("/minitest/autorun.rb") }
+      abort "autorun should not be loaded; loaded features: #{$LOADED_FEATURES.inspect}" if autorun_loaded
+
+      class MinitestEntrypointTest < Minitest::Test
+        def test_installs_the_dsl
+          assert_respond_to self.class, :with_model
+        end
+      end
+
+      exit(Minitest.run ? 0 : 1)
+    RUBY
+  end
+
+  it "configures Test::Unit and extends new test subclasses" do
+    expect_native_runner_to_pass(<<~'RUBY')
+      require "with_model/test_unit"
+      abort "runner: #{WithModel.runner.inspect}" unless WithModel.runner == :test_unit
+
+      class TestUnitEntrypointTest < Test::Unit::TestCase
+        def test_installs_the_dsl
+          assert_respond_to self.class, :with_model
+        end
+      end
+    RUBY
+  end
+
+  it "propagates Test::Unit's LoadError when the framework is unavailable" do
+    Dir.mktmpdir do |directory|
+      Dir.mkdir(File.join(directory, "test"))
+      File.write(
+        File.join(directory, "test/unit.rb"),
+        'raise LoadError, "distinctive test/unit LoadError"'
+      )
+
+      expect_native_runner_to_pass(<<~'RUBY', load_paths: [directory, "lib"])
+        begin
+          require "with_model/test_unit"
+        rescue LoadError => error
+          abort "unexpected LoadError: #{error.message.inspect}" unless
+            error.message == "distinctive test/unit LoadError"
+        else
+          abort "expected a LoadError"
+        end
+      RUBY
+    end
+  end
+
+  it "retains manual Test::Unit setup with plain with_model" do
+    expect_native_runner_to_pass(<<~'RUBY')
+      require "test/unit"
+      require "with_model"
+
+      WithModel.runner = :test_unit
+      Test::Unit::TestCase.extend WithModel
+      abort "runner: #{WithModel.runner.inspect}" unless WithModel.runner == :test_unit
+
+      class PlainWithModelTestUnitTest < Test::Unit::TestCase
+        def test_installs_the_dsl
+          assert_respond_to self.class, :with_model
+        end
+      end
+    RUBY
+  end
+
+  it "retains manual RSpec setup with plain with_model" do
+    expect_native_runner_to_pass(<<~'RUBY')
+      require "rspec"
+      require "with_model"
+
+      WithModel.runner = :rspec
+      RSpec.configure do |config|
+        config.extend WithModel
+      end
+      abort "runner: #{WithModel.runner.inspect}" unless WithModel.runner == :rspec
+
+      RSpec.describe "entrypoint" do
+        it "installs the DSL" do
+          expect(self.class).to respond_to(:with_model)
+        end
+      end
+
+      exit RSpec::Core::Runner.run([])
+    RUBY
+  end
+
+  it "retains manual Minitest setup with plain with_model" do
+    expect_native_runner_to_pass(<<~'RUBY')
+      require "minitest"
+      require "with_model"
+
+      WithModel.runner = :minitest
+      Minitest::Test.extend WithModel
+      abort "runner: #{WithModel.runner.inspect}" unless WithModel.runner == :minitest
+
+      class PlainWithModelMinitestTest < Minitest::Test
+        def test_installs_the_dsl
+          assert_respond_to self.class, :with_model
+        end
+      end
+
+      exit(Minitest.run ? 0 : 1)
+    RUBY
+  end
+end

data/spec/table_false_spec.rb

@@ -21,10 +21,6 @@ RSpec.describe "table(false)" do
     classes = @stubbed_active_record_classes
     next unless classes
 
-    ActiveSupport::DescendantsTracker.clear(classes) \
-      unless ActiveSupport::DescendantsTracker.clear_disabled
-    ActiveSupport::Dependencies::Reference.clear! \
-      if defined?(ActiveSupport::Dependencies::Reference)
     WithModel::DescendantsTracker.clear(classes)
   end
 

data/spec/table_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe WithModel::Table do
+  let(:connection_owner) do
+    klass = Class.new(ActiveRecord::Base)
+    stub_const("TableSpecConnection", klass)
+    klass.abstract_class = true
+    klass.establish_connection(adapter: "sqlite3", database: ":memory:")
+    klass
+  end
+  let(:connection) { connection_owner.connection }
+  let(:table) { described_class.new(:temporary_records, connection:) }
+
+  after { connection_owner.connection_pool.disconnect! }
+
+  describe "#destroy" do
+    it "does not raise after its connection reconnects before teardown" do
+      table.create
+
+      connection.disconnect!
+      connection.reconnect!
+
+      expect(connection.data_source_exists?(:temporary_records)).to be false
+      expect { table.destroy }.not_to raise_error
+    end
+
+    it "drops an existing table" do
+      table.create
+
+      table.destroy
+
+      expect(connection.data_source_exists?(:temporary_records)).to be false
+    end
+  end
+end

data/test_unit/lifecycle_test.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "test_unit_helper"
+
+class TestUnitLifecycleBaseTest < Test::Unit::TestCase
+  FIXTURE_EVENTS = []
+
+  with_model :TestUnitLifecycleParent do
+    table { |t| t.string "name" }
+  end
+
+  def setup
+    FIXTURE_EVENTS.clear
+    assert_kind_of Class, TestUnitLifecycleParent
+    FIXTURE_EVENTS << :inherited_setup
+  end
+
+  def teardown
+    assert_kind_of Class, TestUnitLifecycleParent
+    FIXTURE_EVENTS << :inherited_teardown
+  end
+end
+
+class TestUnitLifecycleTest < TestUnitLifecycleBaseTest
+  with_model :TestUnitLifecycleChild do
+    table do |t|
+      t.references "parent", foreign_key: {to_table: TestUnitLifecycleParent.table_name}
+    end
+
+    model { belongs_to :parent, class_name: TestUnitLifecycleParent.name }
+  end
+
+  def setup
+    super
+    assert_kind_of Class, TestUnitLifecycleChild
+    FIXTURE_EVENTS << :local_setup
+  end
+
+  def teardown
+    assert_kind_of Class, TestUnitLifecycleChild
+    FIXTURE_EVENTS << :local_teardown
+    super
+    return unless name == "test_models_are_available_through_user_fixtures"
+
+    assert_equal [
+      :inherited_setup,
+      :local_setup,
+      :test_body,
+      :local_teardown,
+      :inherited_teardown
+    ], FIXTURE_EVENTS
+  end
+
+  def test_models_are_available_through_user_fixtures
+    parent = TestUnitLifecycleParent.create!(name: "parent")
+    child = TestUnitLifecycleChild.create!(parent: parent)
+
+    assert_equal parent, child.reload.parent
+    FIXTURE_EVENTS << :test_body
+  end
+
+  def test_model_destruction_unwinds_inheritance_order
+    parent_test_case = Class.new(Test::Unit::TestCase) do
+      with_model :TestUnitLifecycleOrderParent do
+        table
+      end
+    end
+    test_case = Class.new(parent_test_case) do
+      teardown(after: :prepend) do
+        assert_false Object.const_defined?(:TestUnitLifecycleOrderChild)
+        assert_false ActiveRecord::Base.connection.data_source_exists?(child_table_name)
+        assert_kind_of Class, TestUnitLifecycleOrderParent
+        assert ActiveRecord::Base.connection.data_source_exists?(parent_table_name)
+      end
+
+      with_model :TestUnitLifecycleOrderChild do
+        table
+      end
+
+      define_method(:parent_table_name) { TestUnitLifecycleOrderParent.table_name }
+      define_method(:child_table_name) { @child_table_name }
+      define_method(:test_lifecycle) { @child_table_name = TestUnitLifecycleOrderChild.table_name }
+    end
+
+    result = Test::Unit::TestResult.new
+    test_case.new("test_lifecycle").run(result) {}
+
+    assert_equal 1, result.run_count
+    assert_equal 0, result.error_count
+  end
+end
+
+class TestUnitUserHookFailureTest < Test::Unit::TestCase
+  def test_setup_error_does_not_prevent_model_cleanup
+    test_case = Class.new(Test::Unit::TestCase) do
+      class << self
+        attr_accessor :created_table_name
+      end
+
+      with_model :TestUnitSetupFailureModel do
+        table
+      end
+
+      def setup
+        self.class.created_table_name = TestUnitSetupFailureModel.table_name
+        raise "setup failed"
+      end
+
+      def test_setup_failure
+      end
+    end
+
+    result = Test::Unit::TestResult.new
+    test_case.new("test_setup_failure").run(result) {}
+
+    assert_hook_failure_cleans_up_model(
+      result,
+      RuntimeError,
+      "setup failed",
+      :TestUnitSetupFailureModel,
+      test_case.created_table_name
+    )
+  end
+
+  def test_teardown_error_does_not_prevent_model_cleanup
+    test_case = Class.new(Test::Unit::TestCase) do
+      class << self
+        attr_accessor :created_table_name
+      end
+
+      with_model :TestUnitTeardownFailureModel do
+        table
+      end
+
+      def teardown
+        self.class.created_table_name = TestUnitTeardownFailureModel.table_name
+        raise "teardown failed"
+      end
+
+      def test_teardown_failure
+      end
+    end
+
+    result = Test::Unit::TestResult.new
+    test_case.new("test_teardown_failure").run(result) {}
+
+    assert_hook_failure_cleans_up_model(
+      result,
+      RuntimeError,
+      "teardown failed",
+      :TestUnitTeardownFailureModel,
+      test_case.created_table_name
+    )
+  end
+
+  private
+
+  def assert_hook_failure_cleans_up_model(result, error_class, message, constant, table_name)
+    assert_equal 1, result.run_count
+    assert_equal 1, result.error_count
+    assert_equal error_class, result.errors.first.exception.class
+    assert_equal message, result.errors.first.exception.message
+    assert_false Object.const_defined?(constant)
+    assert_false ActiveRecord::Base.connection.data_source_exists?(table_name)
+  end
+end
+
+class TestUnitPartialModelCreationFailureTest < Test::Unit::TestCase
+  def test_preserves_the_setup_error_when_model_creation_does_not_assign_a_model
+    test_case = Class.new(Test::Unit::TestCase) do
+      with_model :TestUnitPartiallyCreatedModel, superclass: Object do
+        table(false)
+      end
+
+      def test_setup_failure
+      end
+    end
+
+    result = Test::Unit::TestResult.new
+    test_case.new("test_setup_failure").run(result) {}
+
+    assert_equal 1, result.run_count
+    assert_equal 1, result.error_count
+    assert_kind_of WithModel::InvalidSuperclass, result.errors.first.exception
+  end
+end

data/test_unit/sti_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "test_unit_helper"
+
+# Stands in for an application's own model, the usual reason to want single table
+# inheritance: its table is created once and outlives every test here, so a
+# with_model child's rows cannot be disposed of by dropping the table.
+module TestUnitAppModels
+  class Cupboard < ActiveRecord::Base
+  end
+end
+
+ActiveRecord::Base.connection.create_table TestUnitAppModels::Cupboard.table_name,
+  force: true do |t|
+  t.string "type"
+  t.string "name"
+end
+
+# A with_model parent and an STI child in the same test case. The child's
+# superclass is resolved per-example, so this only works if the parent is
+# created before the child and destroyed after it.
+class TestUnitStiTest < Test::Unit::TestCase
+  with_model :TestUnitVehicle do
+    table do |t|
+      t.string "type"
+      t.string "name"
+    end
+  end
+
+  with_model :TestUnitTruck, superclass: -> { TestUnitVehicle } do
+    table(false)
+  end
+
+  with_model :TestUnitChest, superclass: "TestUnitAppModels::Cupboard" do
+    table(false)
+  end
+
+  def test_the_child_shares_the_parents_table
+    assert_equal TestUnitVehicle.table_name, TestUnitTruck.table_name
+  end
+
+  def test_the_child_stores_its_own_type
+    truck = TestUnitTruck.create!(name: "Ford F-150")
+
+    assert_equal "TestUnitTruck", truck.reload.type
+    assert_instance_of TestUnitTruck, TestUnitVehicle.first
+  end
+
+  # Rows in a table the child does not own have to be deleted when it goes away,
+  # since nothing else will: Cupboard's table is still standing afterwards, and a
+  # row naming a class that no longer exists makes it unloadable. Both tests write
+  # one and first insist the table is empty, so whichever test happens to run
+  # second fails if the rows survived teardown.
+  def test_the_childs_rows_do_not_outlive_it
+    assert_empty TestUnitAppModels::Cupboard.all,
+      "a previous test's rows outlived it"
+
+    TestUnitChest.create!(name: "sideboard")
+
+    assert_equal 1, TestUnitAppModels::Cupboard.count
+  end
+
+  def test_the_childs_rows_leave_the_superclass_loadable
+    assert_empty TestUnitAppModels::Cupboard.all,
+      "a previous test's rows outlived it"
+
+    TestUnitChest.create!(name: "wardrobe")
+
+    assert_instance_of TestUnitChest, TestUnitAppModels::Cupboard.first
+  end
+end

data/test_unit/test_unit_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "active_record"
+require "test/unit"
+require "with_model"
+
+WithModel.runner = :test_unit
+
+Test::Unit::TestCase.extend WithModel
+
+# WithModel requires ActiveRecord::Base.connection to be established.
+# If ActiveRecord already has a connection, as in a Rails app, this is unnecessary.
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")

data/test_unit/with_model_test.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "test_unit_helper"
+
+class TestUnitWithModelTest < Test::Unit::TestCase
+  with_model :TestUnitBlogPost do
+    table { |t| t.string "title" }
+    model { define_method(:fancy_title) { "Title: #{title}" } }
+  end
+
+  with_table :test_unit_widgets do |t|
+    t.string "name"
+  end
+
+  def test_creates_a_temporary_active_record_model
+    record = TestUnitBlogPost.create!(title: "New blog post")
+
+    assert_equal "New blog post", record.reload.title
+  end
+
+  def test_defines_model_methods
+    assert_equal "Title: New blog post", TestUnitBlogPost.new(title: "New blog post").fancy_title
+  end
+
+  def test_defines_the_model_constant
+    assert_kind_of Class, TestUnitBlogPost
+  end
+
+  def test_creates_a_temporary_table
+    assert_true ActiveRecord::Base.connection.data_source_exists?("test_unit_widgets")
+  end
+end
+
+class TestUnitPerDeclarationRunnerTest < Test::Unit::TestCase
+  with_model :TestUnitPerDeclarationModel, runner: :test_unit do
+    table
+  end
+
+  def test_supports_a_test_unit_runner_override
+    assert_kind_of Class, TestUnitPerDeclarationModel
+  end
+end
+
+class TestUnitRunnerValidationTest < Test::Unit::TestCase
+  def test_names_all_supported_runners_for_an_unsupported_runner
+    error = assert_raise(ArgumentError) do
+      Class.new(Test::Unit::TestCase) do
+        extend WithModel
+
+        with_model :UnsupportedTestUnitModel, runner: :unsupported do
+          table
+        end
+      end
+    end
+
+    assert_equal "Unsupported test runner set, expected :rspec, :minitest, or :test_unit", error.message
+  end
+end

data/with_model.gemspec

@@ -9,7 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors = ["Case Commons, LLC", "Grant Hutchins", "Andrew Marshall"]
   spec.email = %w[casecommons-dev@googlegroups.com gems@nertzy.com andrew@johnandrewmarshall.com]
   spec.homepage = "https://github.com/Casecommons/with_model"
-  spec.summary = "Dynamically build a model within an RSpec context"
+  spec.summary = "Dynamically build an Active Record model for " \
+    "RSpec, Minitest, and Test::Unit tests"
   spec.description = spec.summary
   spec.license = "MIT"
   spec.metadata["rubygems_mfa_required"] = "true"
@@ -20,5 +21,5 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = ">= 3.3"
 
-  spec.add_dependency "activerecord", ">= 7.2"
+  spec.add_dependency "activerecord", ">= 8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: with_model
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Case Commons, LLC
@@ -17,15 +17,16 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.2'
-description: Dynamically build a model within an RSpec context
+        version: '8.0'
+description: Dynamically build an Active Record model for RSpec, Minitest, and Test::Unit
+  tests
 email:
 - casecommons-dev@googlegroups.com
 - gems@nertzy.com
@@ -47,29 +48,41 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- docs/minitest.md
+- docs/rspec.md
+- docs/test-unit.md
 - lib/with_model.rb
 - lib/with_model/constant_stubber.rb
 - lib/with_model/descendants_tracker.rb
 - lib/with_model/invalid_superclass.rb
 - lib/with_model/methods.rb
+- lib/with_model/minitest.rb
 - lib/with_model/missing_superclass.rb
 - lib/with_model/model.rb
 - lib/with_model/model/dsl.rb
 - lib/with_model/null_table.rb
+- lib/with_model/rspec.rb
 - lib/with_model/table.rb
+- lib/with_model/test_unit.rb
 - lib/with_model/version.rb
 - spec/active_record_behaviors_spec.rb
 - spec/constant_stubber_spec.rb
 - spec/descendants_tracking_spec.rb
 - spec/readme_spec.rb
+- spec/runner_entrypoints_spec.rb
 - spec/spec_helper.rb
 - spec/table_false_spec.rb
+- spec/table_spec.rb
 - spec/with_model_spec.rb
 - test/declaration_order_test.rb
 - test/spec_dsl_test.rb
 - test/sti_test.rb
 - test/test_helper.rb
 - test/with_model_test.rb
+- test_unit/lifecycle_test.rb
+- test_unit/sti_test.rb
+- test_unit/test_unit_helper.rb
+- test_unit/with_model_test.rb
 - with_model.gemspec
 homepage: https://github.com/Casecommons/with_model
 licenses:
@@ -90,7 +103,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.18
+rubygems_version: 4.0.20
 specification_version: 4
-summary: Dynamically build a model within an RSpec context
+summary: Dynamically build an Active Record model for RSpec, Minitest, and Test::Unit
+  tests
 test_files: []