with_model 2.3.1 → 2.5.0

data/test/own_table_name_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# A `table(false)` model that is its own base class and names an existing table
+# rather than inheriting one. `with_table` is declared first, so the table is
+# created before the model and dropped after it.
+class OwnTableNameTest < Minitest::Test
+  with_table :mythical_beasts do |t|
+    t.string "name"
+  end
+
+  with_model :Hippogriff do
+    table(false)
+
+    model do
+      self.table_name = "mythical_beasts"
+    end
+  end
+
+  def test_the_model_uses_the_table_it_names
+    Hippogriff.create!(name: "Buckbeak")
+
+    assert_equal "mythical_beasts", Hippogriff.table_name
+    assert_equal 1, Hippogriff.count
+  end
+
+  def test_the_model_creates_no_table_of_its_own
+    assert_empty ActiveRecord::Base.connection.tables.grep(/with_model_hippogriff/)
+  end
+end
+
+# A `table(false)` model that is its own base class and uses the table Active
+# Record names after it, without naming it in the model block.
+class ConventionalTableNameTest < Minitest::Test
+  with_table :unicorns do |t|
+    t.string "name"
+  end
+
+  with_model :Unicorn do
+    table(false)
+  end
+
+  def test_the_model_uses_the_table_named_after_it
+    Unicorn.create!(name: "Charlie")
+
+    assert_equal "unicorns", Unicorn.table_name
+    assert_equal 1, Unicorn.count
+  end
+end
+
+# A `table(false)` model whose superclass is abstract and, needing no table, is
+# declared with `table(false)` too.
+class AbstractSuperclassTableNameTest < Minitest::Test
+  with_table :winged_horses do |t|
+    t.string "name"
+  end
+
+  with_model :FlyingCreature do
+    table(false)
+
+    model do
+      self.abstract_class = true
+    end
+  end
+
+  with_model :Pegasus, superclass: :FlyingCreature do
+    table(false)
+
+    model do
+      self.table_name = "winged_horses"
+    end
+  end
+
+  def test_the_model_uses_the_table_it_names
+    Pegasus.create!(name: "Bellerophon")
+
+    assert_equal "winged_horses", Pegasus.table_name
+    assert_equal 1, Pegasus.count
+  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/own_table_name_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "test_unit_helper"
+
+# A `table(false)` model that is its own base class and names an existing table
+# rather than inheriting one. `with_table` is declared first, so the table is
+# created before the model and dropped after it.
+class TestUnitOwnTableNameTest < Test::Unit::TestCase
+  with_table :test_unit_mythical_beasts do |t|
+    t.string "name"
+  end
+
+  with_model :TestUnitHippogriff do
+    table(false)
+
+    model do
+      self.table_name = "test_unit_mythical_beasts"
+    end
+  end
+
+  def test_the_model_uses_the_table_it_names
+    TestUnitHippogriff.create!(name: "Buckbeak")
+
+    assert_equal "test_unit_mythical_beasts", TestUnitHippogriff.table_name
+    assert_equal 1, TestUnitHippogriff.count
+  end
+
+  def test_the_model_creates_no_table_of_its_own
+    assert_empty ActiveRecord::Base.connection.tables.grep(/with_model_test_unit_hippogriff/)
+  end
+end
+
+# A `table(false)` model that is its own base class and uses the table Active
+# Record names after it, without naming it in the model block.
+class TestUnitConventionalTableNameTest < Test::Unit::TestCase
+  with_table :test_unit_unicorns do |t|
+    t.string "name"
+  end
+
+  with_model :TestUnitUnicorn do
+    table(false)
+  end
+
+  def test_the_model_uses_the_table_named_after_it
+    TestUnitUnicorn.create!(name: "Charlie")
+
+    assert_equal "test_unit_unicorns", TestUnitUnicorn.table_name
+    assert_equal 1, TestUnitUnicorn.count
+  end
+end
+
+# A `table(false)` model whose superclass is abstract and, needing no table, is
+# declared with `table(false)` too.
+class TestUnitAbstractSuperclassTableNameTest < Test::Unit::TestCase
+  with_table :test_unit_winged_horses do |t|
+    t.string "name"
+  end
+
+  with_model :TestUnitFlyingCreature do
+    table(false)
+
+    model do
+      self.abstract_class = true
+    end
+  end
+
+  with_model :TestUnitPegasus, superclass: :TestUnitFlyingCreature do
+    table(false)
+
+    model do
+      self.table_name = "test_unit_winged_horses"
+    end
+  end
+
+  def test_the_model_uses_the_table_it_names
+    TestUnitPegasus.create!(name: "Bellerophon")
+
+    assert_equal "test_unit_winged_horses", TestUnitPegasus.table_name
+    assert_equal 1, TestUnitPegasus.count
+  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.5.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,43 @@ 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/own_table_name_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/own_table_name_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 +105,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: []