with_model 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f788d32a4cd252a5254b82928cab9b62b66cfd80e00dd010bdb901b60a6ddc6c
-  data.tar.gz: 2c44d64d8f3225e809c113894ec77df2e64c6dae513a12065e171bd892c80c7d
+  metadata.gz: 82365b7ef365626c49c238c05258d85603f6d9cf18c080c5ef39329c1ecf3346
+  data.tar.gz: d1cf7a5a2f060ab68b1daf20a0495de5a09b706b272387810c3c4acce6e42470
 SHA512:
-  metadata.gz: bbf514f03d362582bf15cd38301a9f2929c559ea702c283bae2c01720f48e3f613e93ce1580906983d567048d7241d70af92b94f54f4d992da06f3497c9afc8e
-  data.tar.gz: 66200b79760795f6d3e622b4b29c13285fb042e4e168f1fea34ac38161bca41e4330a451add6f9a0db777dd20cbde97567cd687c811dff1675a1090a24dc7704
+  metadata.gz: 6c4d55dda6fe90872b8a31799207acfe4a910734f20e26cd870103d4ddee2dac6f7f756474f2982e944337ec06502b507622a95c89d400df64aae763554b04c7
+  data.tar.gz: f3fc56af09b5da30a0bde842ff0cc66d448089a638bce6203485ce9f48fe35014b21c05cb1d1f06fc179f49077c58f365837e2f5ab15534d0781a0f4f297c4d8

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ### Unreleased
 
+### 2.5.0
+
+- Allow `table(false)` for an abstract model, and for a model whose superclass
+  is `ActiveRecord::Base` or abstract when the model has an existing table: the
+  one its model block names with `self.table_name`, or else the one Active
+  Record names after the model. Its rows are left for the suite to clean up.
+
 ### 2.4.0
 
 - Add Test::Unit support, including lifecycle integration for dynamic models and

data/CONTRIBUTING.md

@@ -92,9 +92,27 @@ bundle exec standardrb --fix
 
 ## Changes and releases
 
-Please add a line to `CHANGELOG.md` under `### Unreleased` describing your change
-from the point of view of someone using the gem. Leave `lib/with_model/version.rb`
-alone: version bumps and releases are cut separately by a maintainer, so a bump
-in a pull request only creates a conflict.
+Please add an entry to `CHANGELOG.md` under `### Unreleased` for each change
+someone using the gem would notice. Leave `lib/with_model/version.rb` alone:
+version bumps and releases are cut separately by a maintainer, so a bump in a
+pull request only creates a conflict.
+
+### Changelog format
+
+- Each release has a `### X.Y.Z` heading, newest first, with unreleased changes
+  under `### Unreleased` at the top. Leave a blank line after each heading.
+- Write one bullet per change, from the point of view of someone using the gem:
+  what they can now do or what behaves differently, not how the code changed.
+- Start with a verb in the imperative mood (Add, Allow, Fix, Deprecate, Remove,
+  Require), and write a full sentence ending in a period.
+- Put code, such as method names, options, and constants, in backticks.
+- Wrap lines at 80 columns, indenting continuation lines by two spaces.
+- List dependency changes last, Active Record before Ruby, with added support
+  before a raised minimum: "Add support for Ruby 4.0." then "Require Ruby 3.3
+  or later."
+- Don't cite issue or pull request numbers. The pull request links the issue.
+- Credit contributors from outside the maintainers by name, in parentheses at
+  the end of the entry, as in "Create table in same database as `superclass`
+  (John Doe)."
 
 Last, but not least, have fun.

data/README.md

@@ -237,8 +237,9 @@ end
 A `superclass:` that cannot be used raises `WithModel::InvalidSuperclass`: one
 that is not an Active Record class, one with no table of its own
 (`ActiveRecord::Base`, or an abstract class such as a Rails app's
-`ApplicationRecord`), or one whose table has no inheritance column to tell a
-subclass's rows apart. A name that resolves to nothing raises
+`ApplicationRecord`) when the model has no existing table of its own either (see
+[Existing tables](#existing-tables)), or a concrete one whose table has no
+inheritance column to tell a subclass's rows apart. A name that resolves to nothing raises
 `WithModel::MissingSuperclass`, a kind of `InvalidSuperclass`, quoting the
 constant Ruby could not find — for a namespaced name, that is the segment which
 is actually missing. Both are `ArgumentError`s.
@@ -249,6 +250,64 @@ enough on its own. Rows the model wrote are deleted when it goes away, since the
 name a class that is about to stop existing and would make the superclass
 unloadable.
 
+### Existing tables
+
+`table(false)` also suits a model that maps to a table the suite already has,
+such as a legacy table or one that several models share. Set `self.table_name`
+in the model block, or leave it out to use the table Active Record names after
+the model (`phoenixes` for `Phoenix`):
+
+```ruby
+describe "with_model supports existing tables" do
+  with_table :legendary_creatures do |t|
+    t.string "name"
+  end
+
+  with_model :Phoenix do
+    table(false)
+
+    model do
+      self.table_name = "legendary_creatures"
+    end
+  end
+
+  it "uses the table it names" do
+    Phoenix.create!(name: "Fawkes")
+
+    expect(Phoenix.table_name).to eq "legendary_creatures"
+  end
+end
+```
+
+The table must exist before the model is set up, so declare `with_table` (or
+whatever creates it) first. It belongs to the suite, not the model, so its rows
+are left in place when the model goes away. Clean them up as you would the rest of that table, with
+transactional tests or otherwise.
+
+The superclass can be abstract, as a Rails app's `ApplicationRecord` is. An
+abstract model needs no table, so declare it with `table(false)` as well:
+
+```ruby
+with_model :LegendaryCreature do
+  table(false)
+
+  model do
+    self.abstract_class = true
+  end
+end
+
+with_model :Phoenix, superclass: :LegendaryCreature do
+  table(false)
+
+  model do
+    self.table_name = "legendary_creatures"
+  end
+end
+```
+
+Active Record never applies single table inheritance below an abstract class, so
+an abstract superclass's table, if it has one, needs no inheritance column.
+
 ## Foreign keys
 
 `foreign_key: true` asks Active Record to infer the table a foreign key points

data/lib/with_model/model/dsl.rb

@@ -13,7 +13,9 @@ module WithModel
       #
       # Pass `false` instead of options to create no table at all, so that the
       # model inherits its superclass's table as Rails Single Table Inheritance
-      # requires. `table(false)` takes no block.
+      # requires, or uses an existing table: the one its model block names with
+      # `self.table_name`, or else the one Active Record names after the model.
+      # An abstract model needs no table at all. `table(false)` takes no block.
       #
       # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-create_table
       def table(options = {}, &block)

data/lib/with_model/model.rb

@@ -73,9 +73,7 @@ module WithModel
       # Before `unstub_const`: a teardown that identifies this model's own rows
       # can only do so while the class still has its name.
       table.teardown(@model)
-      stubber.unstub_const
-      WithModel::DescendantsTracker.clear([@model])
-      @model = nil
+      discard_model
     end
 
     private
@@ -127,9 +125,26 @@ module WithModel
     def setup_model
       table.configure(@model)
       @model.class_eval(&@model_block) if @model_block
+      verify_model
       @model.reset_column_information
     end
 
+    # A model rejected here was never usable, so it is discarded at once rather
+    # than left for teardown: there are no rows to clean up, and a caller that
+    # does not tear down would otherwise be left with its constant.
+    def verify_model
+      table.verify(@model)
+    rescue InvalidSuperclass
+      discard_model
+      raise
+    end
+
+    def discard_model
+      stubber.unstub_const
+      WithModel::DescendantsTracker.clear([@model])
+      @model = nil
+    end
+
     def stubber
       @stubber ||= ConstantStubber.new const_name
     end

data/lib/with_model/null_table.rb

@@ -4,9 +4,11 @@ require "active_record"
 require "with_model/invalid_superclass"
 
 module WithModel
-  # Stands in for a {WithModel::Table} when a model should inherit its
-  # superclass's table instead of getting one of its own, as Rails Single Table
-  # Inheritance requires. Selected by `table(false)`.
+  # Stands in for a {WithModel::Table} when a model should not get a table of its
+  # own: either it inherits its superclass's table, as Rails Single Table
+  # Inheritance requires, or it uses an existing table: one its model block
+  # names with `self.table_name`, or the one Active Record names after the
+  # model. An abstract model needs neither. Selected by `table(false)`.
   #
   # In general, direct use of this class should be avoided. Instead use
   # either the {WithModel high-level API} or {WithModel::Model::DSL low-level API}.
@@ -21,7 +23,9 @@ module WithModel
     end
 
     # Creates nothing, but raises {WithModel::InvalidSuperclass} when the
-    # superclass cannot support single table inheritance.
+    # superclass has a table that cannot support single table inheritance.
+    # Whether a superclass with nothing to inherit is a problem depends on the
+    # model block, so that waits for {#verify}.
     #
     # Errors describe the model's situation rather than the call that produced
     # it. Any expression that evaluates to false selects a NullTable, so there
@@ -34,14 +38,13 @@ module WithModel
     # `StatementInvalid` naming the table if it never appears, so raising here
     # would only forbid working setups.
     #
-    # 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.
+    # What is left is {WithModel::InvalidSuperclass}: a missing inheritance
+    # column, like a missing table to inherit, is a permanent fact about the
+    # superclass passed in, not about when it was looked at, so no amount of
+    # waiting makes it work.
     def create
-      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?
+      # Nothing can be checked until there is a table to look at.
+      return unless inheritable_table? && table_exists?
       return if inheritance_column?
 
       raise_invalid_superclass "#{@superclass}'s table #{@superclass.table_name.inspect} has no " \
@@ -54,9 +57,33 @@ module WithModel
     def configure(klass)
     end
 
-    # Removes the rows this model wrote, which would otherwise outlive the
-    # constant that names them and make the superclass unloadable
-    # (`ActiveRecord::SubclassNotFound`).
+    # Raises {WithModel::InvalidSuperclass} when the superclass has no table to
+    # inherit (`ActiveRecord::Base`, or an abstract class) and the model's own
+    # table - the one its block named, or else the one Active Record names after
+    # the model - does not exist once its block has run. A model its block made
+    # abstract needs no table, so it always passes.
+    #
+    # Unlike a superclass's missing table, which {#create} lets through, this
+    # table must already exist. A model with nothing to inherit is far more
+    # likely a mistaken attempt at single table inheritance than a deliberate
+    # reference to a table that is yet to be created, and with nothing to point
+    # at, Active Record's own error would leave that mistake unexplained.
+    def verify(klass)
+      return if klass.abstract_class? || inheritable_table? || own_table_exists?(klass)
+
+      raise_invalid_superclass "#{@superclass} has none to inherit and there is no " \
+        "#{klass.table_name.inspect} table. To use an existing table, create it before " \
+        "the model or set `self.table_name` in its model block."
+    end
+
+    # Removes the rows a single table inheritance subclass wrote, which would
+    # otherwise outlive the constant that names them and make the superclass
+    # unloadable (`ActiveRecord::SubclassNotFound`).
+    #
+    # A model that is its own base class names a table that belongs to the
+    # suite, and its rows name no class, so they are left for the suite to clean
+    # up like the rest of that table - its table need not have an inheritance
+    # column to delete by, either.
     #
     # `unscoped` is required because a `default_scope` on the superclass would
     # otherwise hide rows from cleanup; the inheritance-column condition is
@@ -66,7 +93,7 @@ module WithModel
     # A table that does not exist holds no rows to remove, and failing here
     # would fail an example whose body had already passed.
     def teardown(klass)
-      return unless klass.table_exists?
+      return if klass.base_class? || !klass.table_exists?
 
       klass.unscoped.where(klass.inheritance_column => klass.sti_name).each(&:destroy!)
     end
@@ -79,10 +106,13 @@ module WithModel
 
     def inheritance_column = @superclass.inheritance_column
 
-    # `ActiveRecord::Base` and abstract classes alike have no `table_name`, so
-    # this is what "nothing to inherit" actually looks like - `abstract_class?`
-    # is false for `ActiveRecord::Base` and so does not describe both.
-    def table_name? = @superclass.table_name.present?
+    # `ActiveRecord::Base` has no `table_name`, and an abstract class has none to
+    # pass on through single table inheritance even when it has one: Active
+    # Record makes each of its subclasses a base class of its own. Neither test
+    # covers both, since `abstract_class?` is false for `ActiveRecord::Base`.
+    def inheritable_table? = !@superclass.abstract_class? && @superclass.table_name.present?
+
+    def own_table_exists?(klass) = klass.connection.data_source_exists?(klass.table_name)
 
     def table_exists? = @superclass.table_exists?
 

data/lib/with_model/table.rb

@@ -30,6 +30,12 @@ module WithModel
       klass.table_name = @name
     end
 
+    # Accepts any model block: the table is the model's own. Present so that
+    # {WithModel::NullTable} - which checks the model once its block has run -
+    # can stand in here.
+    def verify(_klass)
+    end
+
     # Removes everything this table holds by dropping it. The model is not
     # needed, but is accepted so that {WithModel::NullTable} - which does need
     # it - can stand in here.

data/lib/with_model/version.rb

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

data/spec/readme_spec.rb

@@ -145,6 +145,26 @@ describe "with_model supports Single Table Inheritance" do
   end
 end
 
+describe "with_model supports existing tables" do
+  with_table :legendary_creatures do |t|
+    t.string "name"
+  end
+
+  with_model :Phoenix do
+    table(false)
+
+    model do
+      self.table_name = "legendary_creatures"
+    end
+  end
+
+  it "uses the table it names" do
+    Phoenix.create!(name: "Fawkes")
+
+    expect(Phoenix.table_name).to eq "legendary_creatures"
+  end
+end
+
 describe "with_model supports foreign keys" do
   with_model :Author do
     table

data/spec/table_false_spec.rb

@@ -433,6 +433,135 @@ RSpec.describe "table(false)" do
     end
   end
 
+  # Not single table inheritance at all: the model is its own base class and
+  # names an existing table, such as a legacy table or one several models share.
+  describe "with a model that sets its own table_name" do
+    with_table :legendary_creatures do |t|
+      t.string :name
+    end
+
+    # Declared between the two so that it runs after the model is torn down but
+    # before the table is dropped.
+    after do
+      expect(ActiveRecord::Base.connection.select_value("SELECT COUNT(*) FROM legendary_creatures"))
+        .to eq @rows_written.to_i
+    end
+
+    with_model :Phoenix do
+      table(false)
+      model do
+        self.table_name = "legendary_creatures"
+      end
+    end
+
+    it "uses the table it names" do
+      Phoenix.create!(name: "Fawkes")
+      @rows_written = 1
+
+      expect(Phoenix.table_name).to eq "legendary_creatures"
+      expect(Phoenix.count).to eq 1
+    end
+
+    it "creates no table of its own" do
+      expect(ActiveRecord::Base.connection.tables.grep(/with_model_phoenix/)).to be_empty
+    end
+
+    it "is its own base class" do
+      expect(Phoenix.base_class).to eq Phoenix
+    end
+
+    # The table belongs to the suite, which is left to clean it up - with
+    # transactional tests, or however it cleans up its other tables. Deleting by
+    # type would fail outright here, since there is no type column.
+    it "leaves its rows alone when torn down" do
+      Phoenix.create!(name: "Fawkes")
+      Phoenix.create!(name: "Buckbeak")
+      @rows_written = 2
+    end
+
+    # An abstract model needs no table, so `table(false)` suits it too.
+    context "with an abstract superclass that has no table" do
+      with_model :ApplicationRecord do
+        table(false)
+        model do
+          self.abstract_class = true
+        end
+      end
+
+      with_model :Griffin, superclass: :ApplicationRecord do
+        table(false)
+        model do
+          self.table_name = "legendary_creatures"
+        end
+      end
+
+      it "uses the table it names" do
+        Griffin.create!(name: "Buckbeak")
+        @rows_written = 1
+
+        expect(Griffin.table_name).to eq "legendary_creatures"
+        expect(Griffin.count).to eq 1
+      end
+
+      it "leaves the abstract superclass without a table" do
+        expect(ApplicationRecord.table_name).to be_nil
+      end
+    end
+
+    # Active Record never applies single table inheritance below an abstract
+    # class, so its table needs no inheritance column.
+    context "with an abstract superclass that has a table" do
+      with_model :LegendaryCreature do
+        table
+        model do
+          self.abstract_class = true
+        end
+      end
+
+      with_model :Sphinx, superclass: :LegendaryCreature do
+        table(false)
+        model do
+          self.table_name = "legendary_creatures"
+        end
+      end
+
+      it "uses the table it names" do
+        Sphinx.create!(name: "Phix")
+        @rows_written = 1
+
+        expect(Sphinx.table_name).to eq "legendary_creatures"
+        expect(Sphinx.count).to eq 1
+      end
+
+      it "is its own base class" do
+        expect(Sphinx.base_class).to eq Sphinx
+      end
+    end
+  end
+
+  # Active Record's naming convention picks the table, so the model block need
+  # not name it.
+  describe "with a model named after an existing table" do
+    with_table :dragons do |t|
+      t.string :name
+    end
+
+    with_model :Dragon do
+      table(false)
+    end
+
+    it "uses that table" do
+      Dragon.create!(name: "Norbert")
+
+      expect(Dragon.table_name).to eq "dragons"
+      expect(Dragon.count).to eq 1
+    end
+
+    it "creates no table of its own" do
+      expect(ActiveRecord::Base.connection.tables.grep(/with_model_dragon/)).to be_empty
+    end
+  end
+
   describe "invalid configurations" do
     # Creates immediately the same tableless subclass normally generated by:
     #
@@ -461,6 +590,46 @@ RSpec.describe "table(false)" do
         .to raise_error(WithModel::InvalidSuperclass, /ActiveRecord::Base has none to inherit/)
     end
 
+    it "names the table it looked for" do
+      expect { create_tableless_subclass(superclass: ActiveRecord::Base) }
+        .to raise_error(WithModel::InvalidSuperclass, /there is no "tableless_subclasses" table/)
+    end
+
+    it "suggests creating that table first or naming another" do
+      expect { create_tableless_subclass(superclass: ActiveRecord::Base) }
+        .to raise_error(
+          WithModel::InvalidSuperclass,
+          /create it before the model or set `self.table_name` in its model block/
+        )
+    end
+
+    # Builds the model by hand so that, should the check let it through, the
+    # example can still destroy it rather than leak its constant.
+    it "looks for the table the model block names" do
+      subclass = WithModel::Model.new(:TablelessSubclass, superclass: ActiveRecord::Base)
+      WithModel::Model::DSL.new(subclass).instance_eval do
+        table(false)
+        model { self.table_name = "missing_furniture" }
+      end
+
+      begin
+        expect { subclass.create }
+          .to raise_error(WithModel::InvalidSuperclass, /there is no "missing_furniture" table/)
+      ensure
+        subclass.destroy if Object.const_defined?(:TablelessSubclass, false)
+      end
+    end
+
+    # The check needs the model block to have run, so the constant already
+    # exists when it fails. A test runner tears down after a failed setup, but
+    # nothing else does, and a leftover constant would leak into later tests.
+    it "leaves no constant behind" do
+      expect { create_tableless_subclass(superclass: ActiveRecord::Base) }
+        .to raise_error(WithModel::InvalidSuperclass)
+
+      expect(Object.const_defined?(:TablelessSubclass, false)).to be false
+    end
+
     context "with an abstract superclass" do
       with_model :TablelessSuperclass do
         table

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/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: with_model
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Case Commons, LLC
@@ -75,11 +75,13 @@ files:
 - 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