with_model 2.1.7 → 2.3.0

data/spec/active_record_behaviors_spec.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-describe 'ActiveRecord behaviors' do
-  describe 'a temporary ActiveRecord model created with with_model' do
-    context 'that has a named scope' do
+describe "ActiveRecord behaviors" do
+  describe "a temporary ActiveRecord model created with with_model" do
+    context "that has a named scope" do
       before do
         @regular_model = Class.new ActiveRecord::Base do
-          self.table_name = 'regular_models'
-          scope :title_is_foo, -> { where(title: 'foo') }
+          self.table_name = "regular_models"
+          scope :title_is_foo, -> { where(title: "foo") }
         end
 
         @regular_model.connection.create_table(@regular_model.table_name, force: true) do |t|
-          t.string 'title'
-          t.text 'content'
+          t.string "title"
+          t.text "content"
           t.timestamps null: false
         end
       end
@@ -24,37 +24,37 @@ describe 'ActiveRecord behaviors' 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
 
         model do
-          scope :title_is_foo, -> { where(title: 'foo') }
+          scope :title_is_foo, -> { where(title: "foo") }
         end
       end
 
-      describe 'the named scope' do
-        it 'works like a regular named scope' do
-          included = @regular_model.create!(title: 'foo', content: 'Include me!')
-          @regular_model.create!(title: 'bar', content: 'Include me!')
+      describe "the named scope" do
+        it "works like a regular named scope" do
+          included = @regular_model.create!(title: "foo", content: "Include me!")
+          @regular_model.create!(title: "bar", content: "Include me!")
 
           expect(@regular_model.title_is_foo).to eq [included]
 
-          included = BlogPost.create!(title: 'foo', content: 'Include me!')
-          BlogPost.create!(title: 'bar', content: 'Include me!')
+          included = BlogPost.create!(title: "foo", content: "Include me!")
+          BlogPost.create!(title: "bar", content: "Include me!")
 
           expect(BlogPost.title_is_foo).to eq [included]
         end
       end
     end
 
-    context 'that has a polymorphic belongs_to' do
+    context "that has a polymorphic belongs_to" do
       before do
         animal = Class.new ActiveRecord::Base do
           has_many :tea_cups, as: :pet
         end
-        stub_const 'Animal', animal
+        stub_const "Animal", animal
       end
 
       with_model :TeaCup do
@@ -69,29 +69,30 @@ describe 'ActiveRecord behaviors' do
       with_table :animals
 
       with_model :StuffedAnimal do
+        table
         model do
           has_many :tea_cups, as: :pet
         end
       end
 
-      describe 'the polymorphic belongs_to' do
-        it 'works like a regular polymorphic belongs_to' do
+      describe "the polymorphic belongs_to" do
+        it "works like a regular polymorphic belongs_to" do
           animal = Animal.create!
           stuffed_animal = StuffedAnimal.create!
 
           tea_cup_for_animal = TeaCup.create!(pet: animal)
-          expect(tea_cup_for_animal.pet_type).to eq 'Animal'
+          expect(tea_cup_for_animal.pet_type).to eq "Animal"
           expect(animal.tea_cups).to include(tea_cup_for_animal)
 
           tea_cup_for_stuffed_animal = TeaCup.create!(pet: stuffed_animal)
-          expect(tea_cup_for_stuffed_animal.pet_type).to eq 'StuffedAnimal'
+          expect(tea_cup_for_stuffed_animal.pet_type).to eq "StuffedAnimal"
           expect(stuffed_animal.tea_cups).to include(tea_cup_for_stuffed_animal)
         end
       end
     end
   end
 
-  context 'with an association' do
+  context "with an association" do
     with_model :Province do
       table do |t|
         t.belongs_to :country
@@ -101,15 +102,17 @@ describe 'ActiveRecord behaviors' do
       end
     end
 
-    with_model :Country
+    with_model :Country do
+      table
+    end
 
-    context 'in earlier examples' do
-      it 'works as normal' do
+    context "in earlier examples" do
+      it "works as normal" do
         expect { Province.create!(country: Country.create!) }.not_to raise_error
       end
     end
 
-    context 'in later examples' do
+    context "in later examples" do
       it "does not hold a reference to earlier example groups' classes" do
         expect(Province.reflect_on_association(:country).klass).to eq Country
       end

data/spec/constant_stubber_spec.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 module WithModel
   describe ConstantStubber do
-    it 'allows calling unstub_const multiple times' do
-      stubber = described_class.new('Foo')
+    it "allows calling unstub_const multiple times" do
+      stubber = described_class.new("Foo")
       stubber.stub_const(1)
       expect { 2.times { stubber.unstub_const } }.not_to raise_error
     end
 
-    it 'allows calling unstub_const without stub_const' do
-      stubber = described_class.new('Foo')
+    it "allows calling unstub_const without stub_const" do
+      stubber = described_class.new("Foo")
       expect { stubber.unstub_const }.not_to raise_error
     end
   end

data/spec/descendants_tracking_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe "Descendants tracking" do
+  with_model :BlogPost do
+    table
+    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
+
+  shared_examples "clearing descendants between test runs" do
+    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]
+    end
+  end
+
+  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
+
+    include_examples "clearing descendants between test runs"
+  end
+
+  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
+end

data/spec/readme_spec.rb

@@ -1,31 +1,35 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-describe 'A blog post' do
-  before do
-    stub_const('MyModule', Module.new)
-  end
+module MyModule; end
+
+# A pre-existing model
+class Car < ActiveRecord::Base
+  self.abstract_class = true
+end
 
+describe "A blog post" do
   with_model :BlogPost do
-    # The table block works just like a migration.
+    # The table block (and an options hash) is passed to Active Record migration’s `create_table`.
     table do |t|
       t.string :title
       t.timestamps null: false
     end
 
-    # The model block works just like the class definition.
+    # The model block is the Active Record model’s class body.
     model do
       include MyModule
+
       has_many :comments
       validates_presence_of :title
 
       def self.some_class_method
-        'chunky'
+        "chunky"
       end
 
       def some_instance_method
-        'bacon'
+        "bacon"
       end
     end
   end
@@ -43,46 +47,46 @@ describe 'A blog post' do
     end
   end
 
-  it 'can be accessed as a constant' do
+  it "can be accessed as a constant" do
     expect(BlogPost).to be
   end
 
-  it 'has the module' do
+  it "has the module" do
     expect(BlogPost.include?(MyModule)).to be true
   end
 
-  it 'has the class method' do
-    expect(BlogPost.some_class_method).to eq 'chunky'
+  it "has the class method" do
+    expect(BlogPost.some_class_method).to eq "chunky"
   end
 
-  it 'has the instance method' do
-    expect(BlogPost.new.some_instance_method).to eq 'bacon'
+  it "has the instance method" do
+    expect(BlogPost.new.some_instance_method).to eq "bacon"
   end
 
-  it 'can do all the things a regular model can' do
+  it "can do all the things a regular model can" do
     record = BlogPost.new
     expect(record).not_to be_valid
-    record.title = 'foo'
+    record.title = "foo"
     expect(record).to be_valid
     expect(record.save).to be true
     expect(record.reload).to eq record
-    record.comments.create!(text: 'Lorem ipsum')
+    record.comments.create!(text: "Lorem ipsum")
     expect(record.comments.count).to eq 1
   end
 
-  # with_model classes can have inheritance.
-  class Car < ActiveRecord::Base
-    self.abstract_class = true
+  # with_model classes can have inheritance. Car is abstract, so it has no table
+  # and Ford gets one of its own. To inherit a concrete superclass's table
+  # instead, see "Single table inheritance" below.
+  with_model :Ford, superclass: Car do
+    table
   end
 
-  with_model :Ford, superclass: Car
-
-  it 'has a specified superclass' do
-    expect(Ford < Car).to be true
+  it "has a specified superclass" do
+    expect(Ford.new).to be_a(Car)
   end
 end
 
-describe 'with_model can be run within RSpec :all hook' do
+describe "with_model can be run within RSpec :all hook" do
   with_model :BlogPost, scope: :all do
     table do |t|
       t.string :title
@@ -93,26 +97,71 @@ describe 'with_model can be run within RSpec :all hook' 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
 
-describe 'another example group' do
-  it 'does not have the constant anymore' do
+describe "another example group" do
+  it "does not have the constant anymore" do
     expect(defined?(BlogPost)).to be_falsy
   end
 end
 
-describe 'with table options' do
+describe "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
+
+describe "with_model supports Single Table Inheritance" do
+  with_model :Sandwich do
+    table do |t|
+      t.string "type"
+      t.string "bread"
+    end
+  end
+
+  with_model :ChunkyBacon, superclass: :Sandwich do
+    table(false)
+  end
+
+  it "shares the superclass's table" do
+    expect(ChunkyBacon.table_name).to eq Sandwich.table_name
+  end
+
+  it "stores its own type" do
+    sandwich = ChunkyBacon.create!(bread: "rye")
+
+    expect(sandwich.reload.type).to eq "ChunkyBacon"
+    expect(Sandwich.first).to be_a ChunkyBacon
+  end
+end
+
+describe "with_model supports foreign keys" do
+  with_model :Author do
+    table
+  end
+
+  with_model :Book do
+    table do |t|
+      t.references :author, foreign_key: {to_table: Author.table_name}
+    end
+
+    model do
+      belongs_to :author
+    end
+  end
+
+  it "has a foreign key" do
+    expect { Book.create!(author_id: 0) }
+      .to raise_error ActiveRecord::InvalidForeignKey
   end
 end

data/spec/spec_helper.rb

@@ -1,16 +1,9 @@
 # frozen_string_literal: true
 
-# Workaround for JRuby CI failure https://github.com/jruby/jruby/issues/6547#issuecomment-774104996
-if RUBY_ENGINE == 'jruby'
-  require 'i18n/backend'
-  require 'i18n/backend/simple'
-end
-
-require 'simplecov'
-SimpleCov.start
+require "bundler/setup"
+require "with_model"
 
-require 'bundler/setup'
-require 'with_model'
+WithModel.deprecator.behavior = :raise
 
 RSpec.configure do |config|
   config.extend WithModel
@@ -26,24 +19,21 @@ RSpec.configure do |config|
   end
 end
 
-is_jruby = RUBY_PLATFORM == 'java'
-adapter = is_jruby ? 'jdbcsqlite3' : 'sqlite3'
-
 # WithModel requires ActiveRecord::Base.connection to be established.
 # If ActiveRecord already has a connection, as in a Rails app, this is unnecessary.
-require 'active_record'
-ActiveRecord::Base.establish_connection(adapter: adapter, database: ':memory:')
+require "active_record"
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
 
 I18n.enforce_available_locales = true if defined?(I18n) && I18n.respond_to?(:enforce_available_locales=)
 
-if ENV['LOGGER']
-  require 'logger'
+if ENV["LOGGER"]
+  require "logger"
   ActiveRecord::Base.logger = Logger.new($stdout)
 end
 
 module SpecHelper
   module RailsTestCompatibility
-    require 'minitest'
+    require "minitest"
     include Minitest::Assertions
 
     def assertions