with_model 2.1.7 → 2.2.0

data/spec/readme_spec.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-describe 'A blog post' do
+describe "A blog post" do
   before do
-    stub_const('MyModule', Module.new)
+    stub_const("MyModule", Module.new)
   end
 
   with_model :BlogPost do
@@ -21,11 +21,11 @@ describe 'A blog post' do
       validates_presence_of :title
 
       def self.some_class_method
-        'chunky'
+        "chunky"
       end
 
       def some_instance_method
-        'bacon'
+        "bacon"
       end
     end
   end
@@ -43,46 +43,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
+  class Car < ActiveRecord::Base # standard:disable Lint/ConstantDefinitionInBlock
     self.abstract_class = true
   end
 
   with_model :Ford, superclass: Car
 
-  it 'has a specified superclass' do
+  it "has a specified superclass" do
     expect(Ford < Car).to be true
   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 +93,26 @@ 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

data/spec/spec_helper.rb

@@ -1,16 +1,7 @@
 # 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"
 
 RSpec.configure do |config|
   config.extend WithModel
@@ -26,24 +17,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

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,123 +58,126 @@ 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
+    context "with the with_model block" do
       with_model :MyConst
 
       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
+  describe "with a plural name" do
     with_model :BlogPosts
 
-    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
+  describe "with a name containing capital letters" do
     with_model :BlogPost
 
-    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
+  describe "with a name with underscores" do
     with_model :blog_post
 
-    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"
 
-    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
       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
       model do
@@ -184,108 +185,109 @@ describe 'a temporary ActiveRecord model created with with_model' do
       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
       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
+  context "without a block" do
     with_model :BlogPost
 
-    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
+    with_model(:BlogPost) {}
 
-    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 +295,32 @@ 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
+  context "without a table or model block" do
     with_model :BlogPost
 
-    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 +331,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