iknow_view_models 3.2.0 → 3.2.1

data/test/unit/view_model/active_record/alias_test.rb

@@ -1,10 +1,12 @@
-require_relative "../../../helpers/arvm_test_utilities.rb"
-require_relative "../../../helpers/arvm_test_models.rb"
-require_relative "../../../helpers/viewmodel_spec_helpers.rb"
+# frozen_string_literal: true
 
-require "minitest/autorun"
+require_relative '../../../helpers/arvm_test_utilities'
+require_relative '../../../helpers/arvm_test_models'
+require_relative '../../../helpers/viewmodel_spec_helpers'
 
-require "view_model/active_record"
+require 'minitest/autorun'
+
+require 'view_model/active_record'
 
 class ViewModel::ActiveRecord::Alias < ActiveSupport::TestCase
   include ARVMTestUtilities
@@ -14,18 +16,18 @@ class ViewModel::ActiveRecord::Alias < ActiveSupport::TestCase
 
   def child_attributes
     super.merge(
-      viewmodel: ->(v) do
-        add_view_alias "ChildA"
-        add_view_alias "ChildB"
-      end
+      viewmodel: ->(_v) do
+        add_view_alias 'ChildA'
+        add_view_alias 'ChildB'
+      end,
     )
   end
 
-  it "permits association types to be aliased" do
-    %w(Child ChildA ChildB).each do |view_alias|
+  it 'permits association types to be aliased' do
+    %w[Child ChildA ChildB].each do |view_alias|
       view = {
-        "_type" => viewmodel_class.view_name,
-        "child" => { "_type" => view_alias },
+        '_type' => viewmodel_class.view_name,
+        'child' => { '_type' => view_alias },
       }
 
       parent = viewmodel_class.deserialize_from_view(view).model

data/test/unit/view_model/active_record/belongs_to_test.rb

@@ -1,10 +1,12 @@
-require_relative "../../../helpers/arvm_test_utilities.rb"
-require_relative "../../../helpers/arvm_test_models.rb"
-require_relative '../../../helpers/viewmodel_spec_helpers.rb'
+# frozen_string_literal: true
 
-require "minitest/autorun"
+require_relative '../../../helpers/arvm_test_utilities'
+require_relative '../../../helpers/arvm_test_models'
+require_relative '../../../helpers/viewmodel_spec_helpers'
 
-require "view_model/active_record"
+require 'minitest/autorun'
+
+require 'view_model/active_record'
 
 class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
   include ARVMTestUtilities
@@ -14,13 +16,13 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
   def setup
     super
 
-    # TODO make a `has_list?` that allows a parent to set all children as an array
-    @model1 = model_class.new(name: "p1",
-                              child: child_model_class.new(name: "p1l"))
+    # TODO: make a `has_list?` that allows a parent to set all children as an array
+    @model1 = model_class.new(name: 'p1',
+                              child: child_model_class.new(name: 'p1l'))
     @model1.save!
 
-    @model2 = model_class.new(name: "p2",
-                              child: child_model_class.new(name: "p2l"))
+    @model2 = model_class.new(name: 'p2',
+                              child: child_model_class.new(name: 'p2l'))
 
     @model2.save!
 
@@ -30,14 +32,14 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
   def test_serialize_view
     view, _refs = serialize_with_references(ModelView.new(@model1))
 
-    assert_equal({ "_type"    => "Model",
-                   "_version" => 1,
-                   "id"       => @model1.id,
-                   "name"     => @model1.name,
-                   "child"    => { "_type"    => "Child",
-                                   "_version" => 1,
-                                   "id"       => @model1.child.id,
-                                   "name"     => @model1.child.name },
+    assert_equal({ '_type'    => 'Model',
+                   '_version' => 1,
+                   'id'       => @model1.id,
+                   'name'     => @model1.name,
+                   'child'    => { '_type'    => 'Child',
+                                   '_version' => 1,
+                                   'id'       => @model1.child.id,
+                                   'name'     => @model1.child.name },
                  },
                  view)
   end
@@ -53,9 +55,9 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
 
   def test_create_from_view
     view = {
-      "_type"    => "Model",
-      "name"     => "p",
-      "child"    => { "_type" => "Child", "name" => "l" },
+      '_type'    => 'Model',
+      'name'     => 'p',
+      'child'    => { '_type' => 'Child', 'name' => 'l' },
     }
 
     pv = ModelView.deserialize_from_view(view)
@@ -64,10 +66,10 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
     assert(!p.changed?)
     assert(!p.new_record?)
 
-    assert_equal("p", p.name)
+    assert_equal('p', p.name)
 
     assert(p.child.present?)
-    assert_equal("l", p.child.name)
+    assert_equal('l', p.child.name)
   end
 
   def test_create_belongs_to_nil
@@ -86,7 +88,7 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
   def test_belongs_to_create
     @model1.update(child: nil)
 
-    alter_by_view!(ModelView, @model1) do |view, refs|
+    alter_by_view!(ModelView, @model1) do |view, _refs|
       view['child'] = { '_type' => 'Child', 'name' => 'cheese' }
     end
 
@@ -96,7 +98,7 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
   def test_belongs_to_replace
     old_child = @model1.child
 
-    alter_by_view!(ModelView, @model1) do |view, refs|
+    alter_by_view!(ModelView, @model1) do |view, _refs|
       view['child'] = { '_type' => 'Child', 'name' => 'cheese' }
     end
 
@@ -108,7 +110,7 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
     old_p1_child = @model1.child
     old_p2_child = @model2.child
 
-    set_by_view!(ModelView, [@model1, @model2]) do |(p1, p2), refs|
+    set_by_view!(ModelView, [@model1, @model2]) do |(p1, p2), _refs|
       p1['child'] = nil
       p2['child'] = update_hash_for(ChildView, old_p1_child)
     end
@@ -122,7 +124,7 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
     old_p1_child = @model1.child
     old_p2_child = @model2.child
 
-    alter_by_view!(ModelView, [@model1, @model2]) do |(p1, p2), refs|
+    alter_by_view!(ModelView, [@model1, @model2]) do |(p1, p2), _refs|
       p1['child'] = update_hash_for(ChildView, old_p2_child)
       p2['child'] = update_hash_for(ChildView, old_p1_child)
     end
@@ -136,22 +138,22 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
     d_context = ModelView.new_deserialize_context
 
     target_child = Child.create
-    from_model  = Model.create(name: 'from', child: target_child)
-    to_model    = Model.create(name: 'p3')
+    from_model = Model.create(name: 'from', child: target_child)
+    to_model = Model.create(name: 'p3')
 
     alter_by_view!(
       ModelView, [from_model, to_model],
       deserialize_context: d_context
-    ) do |(from, to), refs|
+    ) do |(from, to), _refs|
       from['child'] = nil
       to['child']   = update_hash_for(ChildView, target_child)
     end
 
     assert_equal(target_child, to_model.child, 'target child moved')
     assert_equal([ViewModel::Reference.new(ModelView, from_model.id),
-                  ViewModel::Reference.new(ModelView, to_model.id)],
+                  ViewModel::Reference.new(ModelView, to_model.id),],
                  d_context.valid_edit_refs,
-                 "only models are checked for change; child was not")
+                 'only models are checked for change; child was not')
   end
 
   def test_implicit_release_invalid_belongs_to
@@ -174,11 +176,11 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
           t.integer :deleted_child_id
           t.integer :ignored_child_id
         end,
-        model: ->(m) do
+        model: ->(_m) do
           belongs_to :deleted_child, class_name: Child.name, dependent: :delete
           belongs_to :ignored_child, class_name: Child.name
         end,
-        viewmodel: ->(v) do
+        viewmodel: ->(_v) do
           associations :deleted_child, :ignored_child
         end)
     end
@@ -198,7 +200,7 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
     end
 
     def test_no_gc_dependent_ignore
-      model = model_class.create(ignored_child: Child.new(name: "one"))
+      model = model_class.create(ignored_child: Child.new(name: 'one'))
       old_child = model.ignored_child
 
       alter_by_view!(ModelView, model) do |ov, _refs|
@@ -232,7 +234,7 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
     end
 
     def test_renamed_roundtrip
-      alter_by_view!(ModelView, @model) do |view, refs|
+      alter_by_view!(ModelView, @model) do |view, _refs|
         assert_equal({ 'id'       => @model.child.id,
                        '_type'    => 'Child',
                        '_version' => 1,
@@ -284,7 +286,6 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
       end
     end
 
-
     # Do we support replacing a node in the tree and remodeling its children
     # back to it? In theory we want to, but currently we don't: the child node
     # is unresolvable.
@@ -299,8 +300,8 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
     def test_move
       model = Aye.create(bee: Bee.new(cee: Cee.new))
       assert_raises(ViewModel::DeserializationError::ParentNotFound) do
-        alter_by_view!(AyeView, model) do |view, refs|
-          view['bee'].delete("id")
+        alter_by_view!(AyeView, model) do |view, _refs|
+          view['bee'].delete('id')
         end
       end
     end

data/test/unit/view_model/active_record/cache_test.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require "minitest/autorun"
-require "minitest/unit"
-require "minitest/hooks"
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'minitest/hooks'
 
-require_relative "../../../helpers/arvm_test_models.rb"
-require_relative "../../../helpers/arvm_test_utilities.rb"
-require_relative "../../../helpers/viewmodel_spec_helpers.rb"
+require_relative '../../../helpers/arvm_test_models'
+require_relative '../../../helpers/arvm_test_utilities'
+require_relative '../../../helpers/viewmodel_spec_helpers'
 
-require "view_model"
-require "view_model/active_record"
+require 'view_model'
+require 'view_model/active_record'
 
 # IknowCache uses Rails.cache: create a dummy cache.
 
@@ -91,8 +91,8 @@ class ViewModel::ActiveRecord
       end
 
       included do
-        let(:shared)     { shared_model_class.create!(name: "shared1") }
-        let(:root)       { model_class.create!(name: "root1", child: Child.new(name: "owned1"), shared: shared) }
+        let(:shared)     { shared_model_class.create!(name: 'shared1') }
+        let(:root)       { model_class.create!(name: 'root1', child: Child.new(name: 'owned1'), shared: shared) }
         let(:root_view)  { viewmodel_class.new(root) }
       end
     end
@@ -183,13 +183,14 @@ class ViewModel::ActiveRecord
 
             # The cached reference must correspond to the returned data.
             parsed_data = JSON.parse(ref_data)
-            value(parsed_data["id"]).must_equal(id)
-            value(parsed_data["_type"]).must_equal(view_name)
+            value(parsed_data['id']).must_equal(id)
+            value(parsed_data['_type']).must_equal(view_name)
 
             # When the cached reference is to independently cached data
             # (SharedView in this test), make sure that data is correctly
             # cached.
-            next unless view_name == "Shared"
+            next unless view_name == 'Shared'
+
             value(id).must_equal(shared.id)
             cached_shared = read_cache(shared_viewmodel_class, id)
             value(cached_shared).must_be(:present?)
@@ -224,8 +225,8 @@ class ViewModel::ActiveRecord
         end
 
         def change_in_database
-          root.update_attribute(:name, "CHANGEDROOT")
-          shared.update_attribute(:name, "CHANGEDSHARED")
+          root.update_attribute(:name, 'CHANGEDROOT')
+          shared.update_attribute(:name, 'CHANGEDSHARED')
         end
 
         it 'resolves from the cache' do
@@ -243,7 +244,7 @@ class ViewModel::ActiveRecord
           viewmodel_class.viewmodel_cache.clear
 
           cache_data, cache_refs = serialize_with_cache
-          value(cache_data[0]["name"]).must_equal("CHANGEDROOT") # Root view invalidated
+          value(cache_data[0]['name']).must_equal('CHANGEDROOT') # Root view invalidated
           value(cache_refs).must_equal(before_refs) # Shared view not invalidated
         end
 
@@ -301,7 +302,7 @@ class ViewModel::ActiveRecord
           viewmodel_class.viewmodel_cache.delete(root.id)
 
           cache_data, cache_refs = serialize_with_cache
-          value(cache_data[0]["name"]).must_equal("CHANGEDROOT")
+          value(cache_data[0]['name']).must_equal('CHANGEDROOT')
           value(cache_refs).must_equal(before_refs)
         end
 
@@ -311,8 +312,8 @@ class ViewModel::ActiveRecord
 
           # Shared view invalidated, but root view not
           cache_data, cache_hrefs = serialize_with_cache
-          value(cache_data[0]["name"]).must_equal("root1")
-          value(cache_hrefs.values[0]["name"]).must_equal("CHANGEDSHARED")
+          value(cache_data[0]['name']).must_equal('root1')
+          value(cache_hrefs.values[0]['name']).must_equal('CHANGEDSHARED')
         end
 
         it 'can clear a cache via its external cache group' do
@@ -321,12 +322,12 @@ class ViewModel::ActiveRecord
 
           # Shared view invalidated, but root view not
           cache_data, cache_hrefs = serialize_with_cache
-          value(cache_data[0]["name"]).must_equal("root1")
-          value(cache_hrefs.values[0]["name"]).must_equal("CHANGEDSHARED")
+          value(cache_data[0]['name']).must_equal('root1')
+          value(cache_hrefs.values[0]['name']).must_equal('CHANGEDSHARED')
         end
 
         describe 'and a record not in the cache' do
-          let(:root2) { model_class.create!(name: "root2", child: Child.new(name: "owned2"), shared: shared) }
+          let(:root2) { model_class.create!(name: 'root2', child: Child.new(name: 'owned2'), shared: shared) }
 
           def serialize_from_database
             views   = model_class.find(root.id, root2.id).map { |r| viewmodel_class.new(r) }
@@ -354,21 +355,21 @@ class ViewModel::ActiveRecord
             change_in_database
 
             cache_data, cache_refs = serialize_with_cache
-            value(cache_data[0]["name"]).must_equal("root1")
-            value(cache_data[1]["name"]).must_equal("root2")
+            value(cache_data[0]['name']).must_equal('root1')
+            value(cache_data[1]['name']).must_equal('root2')
             value(cache_refs).must_equal(refs)
           end
         end
       end
     end
 
-    describe "with a non-cacheable shared child" do
+    describe 'with a non-cacheable shared child' do
       include ViewModelSpecHelpers::ParentAndSharedBelongsToChild
       def model_attributes
         super.merge(viewmodel: ->(_) { cacheable! })
       end
 
-      let(:root)       { model_class.create!(name: "root1", child: Child.new(name: "owned1")) }
+      let(:root)       { model_class.create!(name: 'root1', child: Child.new(name: 'owned1')) }
       let(:root_view)  { viewmodel_class.new(root) }
 
       include BehavesLikeACache

data/test/unit/view_model/active_record/cloner_test.rb

@@ -1,14 +1,16 @@
-require "minitest/autorun"
-require "minitest/unit"
-require "minitest/hooks"
+# frozen_string_literal: true
 
-require_relative "../../../helpers/arvm_test_models.rb"
-require_relative "../../../helpers/viewmodel_spec_helpers.rb"
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'minitest/hooks'
+
+require_relative '../../../helpers/arvm_test_models'
+require_relative '../../../helpers/viewmodel_spec_helpers'
 
 # MiniTest::Spec.register_spec_type(/./, Minitest::HooksSpec)
 
-require "view_model"
-require "view_model/active_record"
+require 'view_model'
+require 'view_model/active_record'
 
 class ViewModel::ActiveRecord
   class ClonerTest < ActiveSupport::TestCase
@@ -18,7 +20,7 @@ class ViewModel::ActiveRecord
     let(:viewmodel) { create_viewmodel! }
     let(:model)     { viewmodel.model }
 
-    describe "with single model" do
+    describe 'with single model' do
       include ViewModelSpecHelpers::Single
 
       def model_attributes
@@ -26,15 +28,15 @@ class ViewModel::ActiveRecord
       end
 
       def new_model
-        model_class.new(name: "a", nonview: "b")
+        model_class.new(name: 'a', nonview: 'b')
       end
 
-      it "persists the test setup" do
+      it 'persists the test setup' do
         assert(viewmodel.model.persisted?)
         refute(viewmodel.model.new_record?)
       end
 
-      it "can clone the model" do
+      it 'can clone the model' do
         clone_model = Cloner.new.clone(viewmodel)
         assert(clone_model.new_record?)
         assert_nil(clone_model.id)
@@ -45,75 +47,75 @@ class ViewModel::ActiveRecord
       end
 
       class IgnoreParentCloner < Cloner
-        def visit_model_view(node, model)
+        def visit_model_view(_node, _model)
           ignore!
         end
       end
 
-      it "can ignore a model" do
+      it 'can ignore a model' do
         clone_model = IgnoreParentCloner.new.clone(viewmodel)
         assert_nil(clone_model)
       end
 
       class IgnoreAllCloner < Cloner
-        def pre_visit(node, model)
+        def pre_visit(_node, _model)
           ignore!
         end
       end
 
-      it "can ignore a model in pre-visit" do
+      it 'can ignore a model in pre-visit' do
         clone_model = IgnoreAllCloner.new.clone(viewmodel)
         assert_nil(clone_model)
       end
 
       class AlterAttributeCloner < Cloner
-        def visit_model_view(node, model)
-          model.name = "changed"
+        def visit_model_view(_node, model)
+          model.name = 'changed'
         end
       end
 
-      it "can alter a model attribute" do
+      it 'can alter a model attribute' do
         clone_model = AlterAttributeCloner.new.clone(viewmodel)
         assert(clone_model.new_record?)
         assert_nil(clone_model.id)
-        assert_equal("changed", clone_model.name)
-        refute_equal("changed", model.name)
+        assert_equal('changed', clone_model.name)
+        refute_equal('changed', model.name)
         assert_equal(model.nonview, clone_model.nonview)
         clone_model.save!
         refute_equal(model, clone_model)
       end
 
       class PostAlterAttributeCloner < Cloner
-        def end_visit_model_view(node, model)
-          model.name = "changed"
+        def end_visit_model_view(_node, model)
+          model.name = 'changed'
         end
       end
 
-      it "can alter a model attribute post-visit" do
+      it 'can alter a model attribute post-visit' do
         clone_model = PostAlterAttributeCloner.new.clone(viewmodel)
         assert(clone_model.new_record?)
         assert_nil(clone_model.id)
-        assert_equal("changed", clone_model.name)
-        refute_equal("changed", model.name)
+        assert_equal('changed', clone_model.name)
+        refute_equal('changed', model.name)
         assert_equal(model.nonview, clone_model.nonview)
         clone_model.save!
         refute_equal(model, clone_model)
       end
     end
 
-    describe "with a child" do
+    describe 'with a child' do
       def new_child_model
-        child_model_class.new(name: "b")
+        child_model_class.new(name: 'b')
       end
 
       def new_model
-        model_class.new(name: "a", child: new_child_model)
+        model_class.new(name: 'a', child: new_child_model)
       end
 
       module BehavesLikeConstructingAChild
         extend ActiveSupport::Concern
         included do
-          it "persists the test setup" do
+          it 'persists the test setup' do
             assert(viewmodel.model.persisted?)
             refute(viewmodel.model.new_record?)
             assert(viewmodel.model.child.persisted?)
@@ -123,7 +125,7 @@ class ViewModel::ActiveRecord
       end
 
       class IgnoreChildAssociationCloner < Cloner
-        def visit_model_view(node, model)
+        def visit_model_view(_node, _model)
           ignore_association!(:child)
         end
       end
@@ -131,7 +133,7 @@ class ViewModel::ActiveRecord
       module BehavesLikeCloningAChild
         extend ActiveSupport::Concern
         included do
-          it "can clone the model and child" do
+          it 'can clone the model and child' do
             clone_model = Cloner.new.clone(viewmodel)
 
             assert(clone_model.new_record?)
@@ -148,7 +150,7 @@ class ViewModel::ActiveRecord
             refute_equal(model.child, clone_model.child)
           end
 
-          it "can ignore the child association" do
+          it 'can ignore the child association' do
             clone_model = IgnoreChildAssociationCloner.new.clone(viewmodel)
 
             assert(clone_model.new_record?)
@@ -160,66 +162,67 @@ class ViewModel::ActiveRecord
         end
       end
 
-      describe "as belongs_to" do
+      describe 'as belongs_to' do
         include ViewModelSpecHelpers::ParentAndBelongsToChild
         include BehavesLikeConstructingAChild
         include BehavesLikeCloningAChild
       end
 
-      describe "as has_one" do
+      describe 'as has_one' do
         include ViewModelSpecHelpers::ParentAndHasOneChild
         include BehavesLikeConstructingAChild
         include BehavesLikeCloningAChild
       end
 
-      describe "as belongs_to shared child" do
+      describe 'as belongs_to shared child' do
         include ViewModelSpecHelpers::ParentAndSharedBelongsToChild
         include BehavesLikeConstructingAChild
-        it "can clone the model but not the child" do
-            clone_model = Cloner.new.clone(viewmodel)
 
-            assert(clone_model.new_record?)
-            assert_nil(clone_model.id)
-            assert_equal(model.name, clone_model.name)
+        it 'can clone the model but not the child' do
+          clone_model = Cloner.new.clone(viewmodel)
 
-            clone_child = clone_model.child
-            refute(clone_child.new_record?)
-            assert_equal(model.child, clone_child)
+          assert(clone_model.new_record?)
+          assert_nil(clone_model.id)
+          assert_equal(model.name, clone_model.name)
 
-            clone_model.save!
-            refute_equal(model, clone_model)
-            assert_equal(model.child, clone_model.child)
-          end
+          clone_child = clone_model.child
+          refute(clone_child.new_record?)
+          assert_equal(model.child, clone_child)
+
+          clone_model.save!
+          refute_equal(model, clone_model)
+          assert_equal(model.child, clone_model.child)
+        end
       end
     end
 
     class IgnoreChildrenAssociationCloner < Cloner
-      def visit_model_view(node, model)
+      def visit_model_view(_node, _model)
         ignore_association!(:children)
       end
     end
 
-    describe "with has_many children" do
+    describe 'with has_many children' do
       include ViewModelSpecHelpers::ParentAndHasManyChildren
       def new_child_models
-        ["b", "c"].map { |n| child_model_class.new(name: n) }
+        ['b', 'c'].map { |n| child_model_class.new(name: n) }
       end
 
       def new_model
-        model_class.new(name: "a", children: new_child_models)
+        model_class.new(name: 'a', children: new_child_models)
       end
 
-      it "persists the test setup" do
+      it 'persists the test setup' do
         assert(viewmodel.model.persisted?)
         refute(viewmodel.model.new_record?)
         assert_equal(2, viewmodel.model.children.size)
-        viewmodel.model.children.each do | child|
+        viewmodel.model.children.each do |child|
           assert(child.persisted?)
           refute(child.new_record?)
         end
       end
 
-      it "can clone the model" do
+      it 'can clone the model' do
         clone_model = Cloner.new.clone(viewmodel)
 
         assert(clone_model.new_record?)
@@ -244,9 +247,10 @@ class ViewModel::ActiveRecord
       class IgnoreFirstChildCloner < Cloner
         def initialize
           @ignored_first = false
+          super
         end
 
-        def visit_child_view(node, model)
+        def visit_child_view(_node, _model)
           unless @ignored_first
             @ignored_first = true
             ignore!
@@ -254,7 +258,7 @@ class ViewModel::ActiveRecord
         end
       end
 
-      it "can ignore subset of children" do
+      it 'can ignore subset of children' do
         clone_model = IgnoreFirstChildCloner.new.clone(viewmodel)
 
         assert(clone_model.new_record?)
@@ -265,7 +269,7 @@ class ViewModel::ActiveRecord
         assert_equal(model.children[1].name, clone_model.children[0].name)
       end
 
-      it "can ignore the children association" do
+      it 'can ignore the children association' do
         clone_model = IgnoreChildrenAssociationCloner.new.clone(viewmodel)
 
         assert(clone_model.new_record?)
@@ -276,19 +280,19 @@ class ViewModel::ActiveRecord
       end
     end
 
-    describe "with has_many_through shared children" do
+    describe 'with has_many_through shared children' do
       include ViewModelSpecHelpers::ParentAndHasManyThroughChildren
       def new_model_children
-        ["b", "c"].map.with_index do |n, i|
+        ['b', 'c'].map.with_index do |n, i|
           join_model_class.new(child: child_model_class.new(name: n), position: i)
         end
       end
 
       def new_model
-        model_class.new( name: "a", model_children: new_model_children)
+        model_class.new(name: 'a', model_children: new_model_children)
       end
 
-      it "persists the test setup" do
+      it 'persists the test setup' do
         assert(viewmodel.model.persisted?)
         refute(viewmodel.model.new_record?)
         assert_equal(2, viewmodel.model.model_children.size)
@@ -301,7 +305,7 @@ class ViewModel::ActiveRecord
         end
       end
 
-      it "can clone the model and join model but not the child" do
+      it 'can clone the model and join model but not the child' do
         clone_model = Cloner.new.clone(viewmodel)
 
         assert(clone_model.new_record?)
@@ -325,7 +329,7 @@ class ViewModel::ActiveRecord
         end
       end
 
-      it "can ignore the children association" do
+      it 'can ignore the children association' do
         clone_model = IgnoreChildrenAssociationCloner.new.clone(viewmodel)
 
         assert(clone_model.new_record?)