with_model 2.1.7 → 2.3.0

data/spec/with_model_spec.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'active_model'
-require 'spec_helper'
+require "active_model"
+require "spec_helper"
 
-shared_examples_for 'ActiveModel' do
-  require 'active_model/lint'
+shared_examples_for "ActiveModel" do
+  require "active_model/lint"
   include SpecHelper::RailsTestCompatibility
   include ActiveModel::Lint::Tests
 
@@ -12,26 +12,24 @@ shared_examples_for 'ActiveModel' do
   active_model_lint_tests = active_model_methods.map(&:to_s).grep(/^test/)
 
   active_model_lint_tests.each do |method_name|
-    friendly_name = method_name.tr('_', ' ')
+    friendly_name = method_name.tr("_", " ")
 
-    # rubocop:disable RSpec/NoExpectationExample
     example friendly_name do
       public_send method_name.to_sym
     end
-    # rubocop:enable RSpec/NoExpectationExample
   end
 
   before { @model = subject }
 end
 
-describe 'a temporary ActiveRecord model created with with_model' do
+describe "a temporary ActiveRecord model created with with_model" do
   non_shadowing_example_ran = false
 
   describe "which doesn't shadow an existing class" do
     with_model :BlogPost do
       table do |t|
-        t.string 'title'
-        t.text 'content'
+        t.string "title"
+        t.text "content"
         t.timestamps null: false
       end
 
@@ -46,13 +44,13 @@ describe 'a temporary ActiveRecord model created with with_model' do
       non_shadowing_example_ran = true
     end
 
-    it 'acts like a normal ActiveRecord model' do
-      record = BlogPost.create!(title: 'New blog post', content: 'Hello, world!')
+    it "acts like a normal ActiveRecord model" do
+      record = BlogPost.create!(title: "New blog post", content: "Hello, world!")
 
       record.reload
 
-      expect(record.title).to eq 'New blog post'
-      expect(record.content).to eq 'Hello, world!'
+      expect(record.title).to eq "New blog post"
+      expect(record.content).to eq "Hello, world!"
       expect(record.updated_at).to be_present
 
       record.destroy
@@ -60,232 +58,257 @@ describe 'a temporary ActiveRecord model created with with_model' do
       expect { record.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    describe 'the class' do
+    describe "the class" do
       subject { BlogPost.new }
 
-      it_behaves_like 'ActiveModel'
+      it_behaves_like "ActiveModel"
     end
 
-    it 'has the methods defined in its model block' do
-      expect(BlogPost.new(title: 'New blog post').fancy_title).to eq 'Title: New blog post'
+    it "has the methods defined in its model block" do
+      expect(BlogPost.new(title: "New blog post").fancy_title).to eq "Title: New blog post"
     end
 
-    it 'defines a constant' do
+    it "defines a constant" do
       expect(BlogPost).to be_a(Class)
     end
 
-    describe '.with_model?' do
-      it 'returns true' do
+    describe ".with_model?" do
+      it "returns true" do
         expect(BlogPost.with_model?).to be true
       end
     end
 
-    it 'is its own base_class' do
+    it "is its own base_class" do
       expect(BlogPost.base_class).to eq BlogPost
     end
   end
 
-  context 'after an example which uses with_model without shadowing an existing constant' do
-    it 'returns the constant to its undefined state' do
+  context "after an example which uses with_model without shadowing an existing constant" do
+    it "returns the constant to its undefined state" do
       expect(non_shadowing_example_ran).to be true
       expect(defined?(BlogPost)).to be_falsy
     end
   end
 
-  describe 'constant restoration' do
-    before { stub_const('MyConst', 1) }
+  describe "constant restoration" do
+    before { stub_const("MyConst", 1) }
 
     shadowing_example_ran = false
 
-    context 'with the with_model block' do
-      with_model :MyConst
+    context "with the with_model block" do
+      with_model :MyConst do
+        table
+      end
 
       after do
         shadowing_example_ran = true
       end
 
-      it 'shadows that constant' do
+      it "shadows that constant" do
         expect(MyConst).to be_a(Class)
       end
     end
 
-    context 'without the with_model block' do
-      it 'returns the constant to its original value' do
+    context "without the with_model block" do
+      it "returns the constant to its original value" do
         expect(shadowing_example_ran).to be true
         expect(MyConst).to eq 1
       end
     end
   end
 
-  describe 'with a plural name' do
-    with_model :BlogPosts
+  describe "with a plural name" do
+    with_model :BlogPosts do
+      table
+    end
 
-    it 'does not singularize the constant name' do
+    it "does not singularize the constant name" do
       expect(BlogPosts).to be
       expect(-> { BlogPost }).to raise_error(NameError)
     end
   end
 
-  describe 'with a name containing capital letters' do
-    with_model :BlogPost
+  describe "with a name containing capital letters" do
+    with_model :BlogPost do
+      table
+    end
 
-    it 'tableizes the table name' do
+    it "tableizes the table name" do
       expect(BlogPost.table_name).to match(/_blog_posts_/)
       expect(BlogPost.table_name).to eq BlogPost.table_name.downcase
     end
   end
 
-  describe 'with a name with underscores' do
-    with_model :blog_post
+  describe "with a name with underscores" do
+    with_model :blog_post do
+      table
+    end
 
-    it 'constantizes the name' do
+    it "constantizes the name" do
       expect(BlogPost).to be
     end
 
-    it 'tableizes the table name' do
+    it "tableizes the table name" do
       expect(BlogPost.table_name).to match(/_blog_posts_/)
       expect(BlogPost.table_name).to eq BlogPost.table_name.downcase
     end
   end
 
-  describe 'with a name which is namespaced' do
-    before { stub_const('Stuff', Module.new) }
+  describe "with a name which is namespaced" do
+    before { stub_const("Stuff", Module.new) }
 
-    with_model :'Stuff::BlogPost'
+    with_model :"Stuff::BlogPost" do
+      table
+    end
 
-    it 'creates the model in the namespace' do
+    it "creates the model in the namespace" do
       expect(defined?(BlogPost)).to be_falsey
       expect(defined?(Stuff::BlogPost)).to be_truthy
     end
   end
 
-  describe 'using the constant in the model block' do
+  describe "using the constant in the model block" do
     with_model :BlogPost do
+      table
       model do
-        raise 'I am not myself!' unless self == BlogPost
+        raise "I am not myself!" unless self == BlogPost
       end
     end
 
-    it 'is available' do
+    it "is available" do
       expect(BlogPost).to be
     end
   end
 
-  context 'with a mixin' do
+  context "with a mixin" do
     let(:mixin) do
-      Module.new { def foo; end }
+      Module.new {
+        def foo
+        end
+      }
     end
 
-    before { stub_const('AMixin', mixin) }
+    before { stub_const("AMixin", mixin) }
 
     with_model :WithAMixin do
+      table
       model do
         include AMixin
       end
     end
 
-    it 'has the mixin' do
+    it "has the mixin" do
       expect(-> { WithAMixin.new.foo }).not_to raise_error
       expect(WithAMixin.include?(AMixin)).to be true
     end
   end
 
-  context 'with a mixin that has a class_eval' do
+  context "with a mixin that has a class_eval" do
     subject { WithAClassEval.new }
 
     let(:mixin) do
       Module.new do
         def self.included(klass)
           klass.class_eval do
-            after_save { |object| object.my_method } # rubocop:disable Style/SymbolProc
+            after_save { |object| object.my_method }
           end
         end
       end
     end
 
-    before { stub_const('AMixin', mixin) }
+    before { stub_const("AMixin", mixin) }
 
     with_model :WithAClassEval do
+      table
       model do
         include AMixin
-        def my_method; end
+
+        def my_method
+        end
       end
     end
 
-    it 'only has one after_save callback' do
+    it "only has one after_save callback" do
       expect(subject).to receive(:my_method).once
       subject.save
     end
 
-    it 'still only has one after_save callback in future tests' do
+    it "still only has one after_save callback in future tests" do
       expect(subject).to receive(:my_method).once
       subject.save
     end
   end
 
-  context 'with table options' do
+  context "with table options" do
     with_model :WithOptions do
       table id: false do |t|
-        t.string 'foo'
+        t.string "foo"
         t.timestamps null: false
       end
     end
 
-    it 'respects the additional options' do
-      expect(WithOptions.columns.map(&:name)).not_to include('id')
+    it "respects the additional options" do
+      expect(WithOptions.columns.map(&:name)).not_to include("id")
     end
   end
 
-  context 'without a block' do
-    with_model :BlogPost
+  # Omitting `table` is deprecated, but still supported for the rest of 2.x.
+  # These three contexts are its only coverage, so they keep omitting it and
+  # silence the warning rather than adopting the replacement spelling.
+  context "without a block" do
+    WithModel.deprecator.silence do
+      with_model :BlogPost
+    end
 
-    it 'acts like a normal ActiveRecord model' do
+    it "acts like a normal ActiveRecord model" do
       record = BlogPost.create!
       record.reload
       record.destroy
       expect { record.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    describe 'the class' do
+    describe "the class" do
       subject { BlogPost.new }
 
-      it_behaves_like 'ActiveModel'
+      it_behaves_like "ActiveModel"
     end
   end
 
-  context 'with an empty block' do
-    with_model(:BlogPost) {} # rubocop:disable Lint/EmptyBlock
+  context "with an empty block" do
+    WithModel.deprecator.silence do
+      with_model(:BlogPost) {}
+    end
 
-    it 'acts like a normal ActiveRecord model' do
+    it "acts like a normal ActiveRecord model" do
       record = BlogPost.create!
       record.reload
       record.destroy
       expect { record.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    describe 'the class' do
+    describe "the class" do
       subject { BlogPost.new }
 
-      it_behaves_like 'ActiveModel'
+      it_behaves_like "ActiveModel"
     end
   end
 
-  context 'without a model block' do
+  context "without a model block" do
     with_model :BlogPost do
       table do |t|
-        t.string 'title'
-        t.text 'content'
+        t.string "title"
+        t.text "content"
         t.timestamps null: false
       end
     end
 
-    it 'acts like a normal ActiveRecord model' do
-      record = BlogPost.create!(title: 'New blog post', content: 'Hello, world!')
+    it "acts like a normal ActiveRecord model" do
+      record = BlogPost.create!(title: "New blog post", content: "Hello, world!")
 
       record.reload
 
-      expect(record.title).to eq 'New blog post'
-      expect(record.content).to eq 'Hello, world!'
+      expect(record.title).to eq "New blog post"
+      expect(record.content).to eq "Hello, world!"
       expect(record.updated_at).to be_present
 
       record.destroy
@@ -293,56 +316,34 @@ describe 'a temporary ActiveRecord model created with with_model' do
       expect { record.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    describe 'the class' do
+    describe "the class" do
       subject { BlogPost.new }
 
-      it_behaves_like 'ActiveModel'
+      it_behaves_like "ActiveModel"
     end
   end
 
-  context 'without a table or model block' do
-    with_model :BlogPost
+  context "without a table or model block" do
+    WithModel.deprecator.silence do
+      with_model :BlogPost
+    end
 
-    it 'acts like a normal ActiveRecord model' do
-      expect(BlogPost.columns.map(&:name)).to eq ['id']
+    it "acts like a normal ActiveRecord model" do
+      expect(BlogPost.columns.map(&:name)).to eq ["id"]
       record = BlogPost.create!
       record.reload
       record.destroy
       expect { record.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
-    describe 'the class' do
+    describe "the class" do
       subject { BlogPost.new }
 
-      it_behaves_like 'ActiveModel'
-    end
-  end
-
-  context 'with ActiveSupport::DescendantsTracker' do
-    with_model :BlogPost do
-      model do
-        def self.inspect
-          "BlogPost class #{object_id}"
-        end
-      end
-    end
-
-    def blog_post_classes
-      ActiveRecord::Base.descendants.select do |c|
-        c.table_name == BlogPost.table_name
-      end
-    end
-
-    it 'includes the correct model class in descendants on the first test run' do
-      expect(blog_post_classes).to eq [BlogPost]
-    end
-
-    it 'includes the correct model class in descendants on the second test run' do
-      expect(blog_post_classes).to eq [BlogPost]
+      it_behaves_like "ActiveModel"
     end
   end
 
-  context 'with_model can be run within RSpec :all hook' do
+  context "with_model can be run within RSpec :all hook" do
     with_model :BlogPost, scope: :all do
       table do |t|
         t.string :title
@@ -353,42 +354,55 @@ describe 'a temporary ActiveRecord model created with with_model' do
       BlogPost.create # without scope: :all these will fail
     end
 
-    it 'has been initialized within before(:all)' do
+    it "has been initialized within before(:all)" do
       expect(BlogPost.count).to eq 1
     end
   end
 
   context "with 'superclass' option" do
-    class BlogPostParent < ActiveRecord::Base
+    class BlogPostParent < ActiveRecord::Base # standard:disable Lint/ConstantDefinitionInBlock
       self.abstract_class = true
     end
 
-    after(:all) do
-      Object.__send__(:remove_const, 'BlogPostParent')
-    end
-
     with_model :BlogPost, superclass: BlogPostParent do
       table do |t|
-        t.string 'title'
+        t.string "title"
       end
     end
 
-    describe 'the class' do
+    describe "the class" do
       subject { BlogPost.new }
 
-      it_behaves_like 'ActiveModel'
+      it_behaves_like "ActiveModel"
     end
 
-    it 'is a subclass of the supplied superclass' do
+    it "is a subclass of the supplied superclass" do
       expect(BlogPost < BlogPostParent).to be true
     end
 
-    it 'is its own base_class' do
+    it "is its own base_class" do
       expect(BlogPost.base_class).to eq BlogPost
     end
 
-    it 'responds to .with_model? with true' do
+    it "responds to .with_model? with true" do
       expect(BlogPost.with_model?).to be true
     end
   end
+
+  context "with 'superclass' that connects to a different database" do
+    class ApplicationRecordInDifferentDatabase < ActiveRecord::Base # standard:disable Lint/ConstantDefinitionInBlock
+      self.abstract_class = true
+      establish_connection(ActiveRecord::Base.connection_pool.db_config.configuration_hash)
+    end
+
+    with_model :BlogPost, superclass: ApplicationRecordInDifferentDatabase do
+      table do |t|
+        t.string "title"
+      end
+    end
+
+    it "uses the superclass connection" do
+      expect(BlogPost.connection.tables).to include(BlogPost.table_name)
+    end
+  end
 end

data/test/declaration_order_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Models are created in declaration order and destroyed in reverse, so each one
+# can depend on the ones above it for as long as it exists. Both halves of that
+# are tested here.
+#
+# The model block is evaluated when the model is created, so a model that
+# refers to another one by constant can only work if the model it refers to
+# was created first.
+class DeclarationOrderTest < Minitest::Test
+  with_model :Author do
+    table do |t|
+      t.string "name"
+    end
+  end
+
+  with_model :Book do
+    table do |t|
+      t.integer "author_id"
+    end
+
+    model do
+      belongs_to :author, class_name: Author.name
+    end
+  end
+
+  with_model :Shelf do
+    table do |t|
+      t.string "name"
+    end
+  end
+
+  # `to_table` because `foreign_key: true` would infer a table name from the
+  # column rather than asking the model, and with_model's table names are
+  # generated.
+  with_model :Jar do
+    table do |t|
+      t.references "shelf", foreign_key: {to_table: Shelf.table_name}
+    end
+  end
+
+  def test_a_model_can_refer_to_one_declared_above_it
+    author = Author.create!(name: "Ursula K. Le Guin")
+    book = Book.create!(author: author)
+
+    assert_equal author, book.reload.author
+  end
+
+  # The assertion for teardown order is that this test finishes cleanly. A
+  # referenced table cannot be dropped while a row still points at it, so tearing
+  # these down in declaration order raises ActiveRecord::InvalidForeignKey after
+  # the body has already passed.
+  def test_a_table_can_point_at_one_declared_above_it
+    shelf = Shelf.create!(name: "pantry")
+    jar = Jar.create!(shelf_id: shelf.id)
+
+    assert_equal shelf.id, jar.reload.shelf_id
+  end
+end

data/test/spec_dsl_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# The README offers Minitest::Spec as well as Minitest::Test. Minitest::Spec
+# inherits from Minitest::Test, so extending Minitest::Test reaches describe
+# blocks too, and with_model needs no separate wiring for them.
+describe "with_model in a spec-style suite" do
+  with_model :Sofa do
+    table do |t|
+      t.string "type"
+      t.string "fabric"
+    end
+  end
+
+  with_model :Loveseat, superclass: :Sofa do
+    table(false)
+  end
+
+  it "creates the models a describe block declares" do
+    assert_empty Sofa.all, "another test's rows outlived it"
+
+    Loveseat.create!(fabric: "tweed")
+
+    assert_equal Sofa.table_name, Loveseat.table_name
+    assert_instance_of Loveseat, Sofa.first
+  end
+
+  # Every describe is its own subclass of the one around it, so a nested block
+  # inherits the models declared above it and can add more of its own.
+  describe "and a nested describe" do
+    with_model :Ottoman do
+      table do |t|
+        t.string "name"
+      end
+    end
+
+    it "sees the models from both levels" do
+      assert_empty Sofa.all, "another test's rows outlived it"
+
+      Ottoman.create!(name: "pouf")
+      Loveseat.create!(fabric: "velvet")
+
+      assert_equal 1, Ottoman.count
+      assert_equal 1, Sofa.count
+    end
+  end
+end