iknow_view_models 3.2.0 → 3.2.1

data/test/unit/view_model/active_record/has_many_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::HasManyTest < ActiveSupport::TestCase
   include ARVMTestUtilities
@@ -15,15 +17,15 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   def setup
     super
 
-    @model1 = model_class.new(name: "p1",
-                          children: [child_model_class.new(name: "p1c1", position: 1),
-                                     child_model_class.new(name: "p1c2", position: 2),
-                                     child_model_class.new(name: "p1c3", position: 3)])
+    @model1 = model_class.new(name: 'p1',
+                          children: [child_model_class.new(name: 'p1c1', position: 1),
+                                     child_model_class.new(name: 'p1c2', position: 2),
+                                     child_model_class.new(name: 'p1c3', position: 3),])
     @model1.save!
 
-    @model2 = model_class.new(name: "p2",
-                          children: [child_model_class.new(name: "p2c1").tap { |c| c.position = 1 },
-                                     child_model_class.new(name: "p2c2").tap { |c| c.position = 2 }])
+    @model2 = model_class.new(name: 'p2',
+                          children: [child_model_class.new(name: 'p2c1').tap { |c| c.position = 1 },
+                                     child_model_class.new(name: 'p2c2').tap { |c| c.position = 2 },])
 
     @model2.save!
 
@@ -35,22 +37,21 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     childviews = parentview.load_associated(:children)
     assert_equal(3, childviews.size)
-    assert_equal(["p1c1", "p1c2", "p1c3"],
+    assert_equal(['p1c1', 'p1c2', 'p1c3'],
                  childviews.map(&:name))
   end
 
   def test_serialize_view
     view, _refs = serialize_with_references(viewmodel_class.new(@model1))
 
-
-    assert_equal({ "_type"    => "Model",
-                   "_version" => 1,
-                   "id"       => @model1.id,
-                   "name"     => @model1.name,
-                   "children" => @model1.children.map { |child| { "_type"    => "Child",
-                                                                   "_version" => 1,
-                                                                   "id"       => child.id,
-                                                                   "name"     => child.name } } },
+    assert_equal({ '_type'    => 'Model',
+                   '_version' => 1,
+                   'id'       => @model1.id,
+                   'name'     => @model1.name,
+                   'children' => @model1.children.map { |child| { '_type' => 'Child',
+                                                                   '_version' => 1,
+                                                                   'id'       => child.id,
+                                                                   'name'     => child.name } } },
                  view)
   end
 
@@ -64,10 +65,10 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   def test_create_from_view
     view = {
-      "_type"    => "Model",
-      "name"     => "p",
-      "children" => [{ "_type" => "Child", "name" => "c1" },
-                     { "_type" => "Child", "name" => "c2" }]
+      '_type'    => 'Model',
+      'name'     => 'p',
+      'children' => [{ '_type' => 'Child', 'name' => 'c1' },
+                     { '_type' => 'Child', 'name' => 'c2' },],
     }
 
     pv = viewmodel_class.deserialize_from_view(view)
@@ -76,7 +77,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     assert(!p.changed?)
     assert(!p.new_record?)
 
-    assert_equal("p", p.name)
+    assert_equal('p', p.name)
 
     assert_equal(2, p.children.count)
     p.children.order(:id).each_with_index do |c, i|
@@ -91,7 +92,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     assert_raises(ViewModel::AccessControlError) do
       # append child
-      viewmodel_class.new(@model1).append_associated(:children, { "_type" => "Child", "name" => "hi" }, deserialize_context: no_edit_context)
+      viewmodel_class.new(@model1).append_associated(:children, { '_type' => 'Child', 'name' => 'hi' }, deserialize_context: no_edit_context)
     end
 
     assert_raises(ViewModel::AccessControlError) do
@@ -110,7 +111,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     view = { '_type'    => 'Model',
              'name'     => 'p',
              'children' => [{ '_type' => 'Child', 'name' => 'c1' },
-                            { '_type' => 'Child', 'name' => 'c2' }] }
+                            { '_type' => 'Child', 'name' => 'c2' },] }
 
     context = viewmodel_class.new_deserialize_context
     pv = viewmodel_class.deserialize_from_view(view, deserialize_context: context)
@@ -124,8 +125,8 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   def test_nil_multiple_association
     view = {
-      "_type" => "Model",
-      "children" => nil
+      '_type' => 'Model',
+      'children' => nil,
     }
     ex = assert_raises(ViewModel::DeserializationError::InvalidSyntax) do
       viewmodel_class.deserialize_from_view(view)
@@ -136,8 +137,8 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   def test_non_array_multiple_association
     view = {
-      "_type" => "Model",
-      "children" => { '_type' => 'Child', 'name' => 'c1' }
+      '_type' => 'Model',
+      'children' => { '_type' => 'Child', 'name' => 'c1' },
     }
     ex = assert_raises(ViewModel::DeserializationError::InvalidSyntax) do
       viewmodel_class.deserialize_from_view(view)
@@ -149,7 +150,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   def test_replace_has_many
     old_children = @model1.children
 
-    alter_by_view!(viewmodel_class, @model1) do |view, refs|
+    alter_by_view!(viewmodel_class, @model1) do |view, _refs|
       view['children'] = [{ '_type' => 'Child', 'name' => 'new_child' }]
     end
 
@@ -169,7 +170,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     expected_edit_checks = [pv.to_reference,
                             *old_children.map { |x| ViewModel::Reference.new(child_viewmodel_class, x.id) },
-                            *nc.map(&:to_reference)]
+                            *nc.map(&:to_reference),]
 
     assert_contains_exactly(expected_edit_checks,
                             context.valid_edit_refs)
@@ -200,7 +201,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     expected_edit_checks = [pv.to_reference,
                             ViewModel::Reference.new(child_viewmodel_class, new_child.id),
                             ViewModel::Reference.new(child_viewmodel_class, old_children.first.id),
-                            ViewModel::Reference.new(child_viewmodel_class, old_children.last.id)]
+                            ViewModel::Reference.new(child_viewmodel_class, old_children.last.id),]
 
     assert_contains_exactly(expected_edit_checks,
                             context.valid_edit_refs)
@@ -215,7 +216,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   def test_remove_has_many
     old_children = @model1.children
-    _, context = alter_by_view!(viewmodel_class, @model1) do |view, refs|
+    _, context = alter_by_view!(viewmodel_class, @model1) do |view, _refs|
       view['children'] = []
     end
 
@@ -239,7 +240,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
                          deserialize_context: context)
 
     expected_edit_checks = [ViewModel::Reference.new(viewmodel_class, @model1.id),
-                            ViewModel::Reference.new(child_viewmodel_class,  c1.id)].to_set
+                            ViewModel::Reference.new(child_viewmodel_class, c1.id),].to_set
 
     assert_equal(expected_edit_checks,
                  context.valid_edit_refs.to_set)
@@ -260,8 +261,8 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     assert_contains_exactly(
       [ViewModel::Reference.new(viewmodel_class, @model1.id),
-       ViewModel::Reference.new(child_viewmodel_class,  c1.id),  # deleted child
-       ViewModel::Reference.new(child_viewmodel_class,  nc.id)], # created child
+       ViewModel::Reference.new(child_viewmodel_class,  c1.id), # deleted child
+       ViewModel::Reference.new(child_viewmodel_class,  nc.id),], # created child
       context.valid_edit_refs)
 
     assert_equal([c2, c3, child_model_class.find_by_name('new_c')],
@@ -314,7 +315,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
                          deserialize_context: (context = viewmodel_class.new_deserialize_context))
 
     expected_edit_checks = [ViewModel::Reference.new(viewmodel_class, @model1.id),
-                            ViewModel::Reference.new(viewmodel_class, @model2.id)]
+                            ViewModel::Reference.new(viewmodel_class, @model2.id),]
 
     assert_contains_exactly(expected_edit_checks, context.valid_edit_refs)
 
@@ -335,7 +336,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     n1 = child_model_class.find_by_name('new1')
 
     expected_edit_checks = [ViewModel::Reference.new(viewmodel_class, @model1.id),
-                            ViewModel::Reference.new(child_viewmodel_class, n1.id)]
+                            ViewModel::Reference.new(child_viewmodel_class, n1.id),]
 
     assert_contains_exactly(expected_edit_checks, context.valid_edit_refs)
 
@@ -351,7 +352,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     n2 = child_model_class.find_by_name('new2')
 
     expected_edit_checks = [ViewModel::Reference.new(viewmodel_class, @model1.id),
-                            ViewModel::Reference.new(child_viewmodel_class, n2.id)]
+                            ViewModel::Reference.new(child_viewmodel_class, n2.id),]
 
     assert_contains_exactly(expected_edit_checks, context.valid_edit_refs)
 
@@ -366,7 +367,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     n3 = child_model_class.find_by_name('new3')
 
     expected_edit_checks = [ViewModel::Reference.new(viewmodel_class, @model1.id),
-                            ViewModel::Reference.new(child_viewmodel_class, n3.id)]
+                            ViewModel::Reference.new(child_viewmodel_class, n3.id),]
 
     assert_contains_exactly(expected_edit_checks, context.valid_edit_refs)
 
@@ -377,7 +378,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   def test_edit_implicit_list_position
     c1, c2, c3 = @model1.children.order(:position).to_a
 
-    alter_by_view!(viewmodel_class, @model1) do |view, refs|
+    alter_by_view!(viewmodel_class, @model1) do |view, _refs|
       view['children'].reverse!
       view['children'].insert(1, { '_type' => 'Child', 'name' => 'new_c' })
     end
@@ -388,11 +389,11 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   def test_edit_missing_child
     view = {
-      "_type" => "Model",
-      "children" => [{
-                       "_type" => "Child",
-                       "id"    => 9999
-                     }]
+      '_type' => 'Model',
+      'children' => [{
+                       '_type' => 'Child',
+                       'id'    => 9999,
+                     }],
     }
 
     ex = assert_raises(ViewModel::DeserializationError::NotFound) do
@@ -411,7 +412,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     view = { '_type'    => 'Model',
              'name'     => 'new_p',
              'children' => [moved_child_ref,
-                            { '_type' => 'Child', 'name' => 'new' }] }
+                            { '_type' => 'Child', 'name' => 'new' },] }
 
     retained_children = old_children - [moved_child]
     release_view = { '_type'    => 'Model',
@@ -430,7 +431,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     # child should be added to new parent
     new_children = new_parent.children.order(:position)
-    assert_equal(%w(p1c2 new), new_children.map(&:name))
+    assert_equal(%w[p1c2 new], new_children.map(&:name))
     assert_equal(moved_child, new_children.first)
   end
 
@@ -470,7 +471,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     retained_children = old_children - [moved_child]
     release_view = { '_type' => 'Model', 'id' => @model1.id,
-                     'children' => retained_children.map { |c| update_hash_for(child_viewmodel_class, c) }}
+                     'children' => retained_children.map { |c| update_hash_for(child_viewmodel_class, c) } }
 
     viewmodel_class.deserialize_from_view([view, release_view])
 
@@ -482,25 +483,25 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     # child should be added to new parent with valid position
     new_children = @model2.children.order(:position)
-    assert_equal(%w(p2c1 p2c2 p1c2), new_children.map(&:name))
+    assert_equal(%w[p2c1 p2c2 p1c2], new_children.map(&:name))
     assert_equal(moved_child, new_children.last)
   end
 
   def test_has_many_append_child
-    viewmodel_class.new(@model1).append_associated(:children, { "_type" => "Child", "name" => "new" })
+    viewmodel_class.new(@model1).append_associated(:children, { '_type' => 'Child', 'name' => 'new' })
 
     @model1.reload
 
     assert_equal(4, @model1.children.size)
     lc = @model1.children.order(:position).last
-    assert_equal("new", lc.name)
+    assert_equal('new', lc.name)
   end
 
   def test_has_many_append_and_update_existing_association
     child = @model1.children[1]
 
     cv = child_viewmodel_class.new(child).to_hash
-    cv["name"] = "newname"
+    cv['name'] = 'newname'
 
     viewmodel_class.new(@model1).append_associated(:children, cv)
 
@@ -509,28 +510,28 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     # Child should have been moved to the end (and edited)
     assert_equal(3, @model1.children.size)
     c1, c2, c3 = @model1.children.order(:position)
-    assert_equal("p1c1", c1.name)
-    assert_equal("p1c3", c2.name)
+    assert_equal('p1c1', c1.name)
+    assert_equal('p1c3', c2.name)
     assert_equal(child, c3)
-    assert_equal("newname", c3.name)
+    assert_equal('newname', c3.name)
   end
 
   def test_has_many_move_existing_association
     p1c2 = @model1.children[1]
     assert_equal(2, p1c2.position)
 
-    viewmodel_class.new(@model2).append_associated("children", { "_type" => "Child", "id" => p1c2.id })
+    viewmodel_class.new(@model2).append_associated('children', { '_type' => 'Child', 'id' => p1c2.id })
 
     @model1.reload
     @model2.reload
 
     p1c = @model1.children.order(:position)
     assert_equal(2, p1c.size)
-    assert_equal(["p1c1", "p1c3"], p1c.map(&:name))
+    assert_equal(['p1c1', 'p1c3'], p1c.map(&:name))
 
     p2c = @model2.children.order(:position)
     assert_equal(3, p2c.size)
-    assert_equal(["p2c1", "p2c2", "p1c2"], p2c.map(&:name))
+    assert_equal(['p2c1', 'p2c2', 'p1c2'], p2c.map(&:name))
     assert_equal(p1c2, p2c[2])
     assert_equal(3, p2c[2].position)
   end
@@ -545,8 +546,8 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     # Child should have been removed
     assert_equal(2, @model1.children.size)
     c1, c2 = @model1.children.order(:position)
-    assert_equal("p1c1", c1.name)
-    assert_equal("p1c3", c2.name)
+    assert_equal('p1c1', c1.name)
+    assert_equal('p1c3', c2.name)
 
     assert_equal(0, child_model_class.where(id: child.id).size)
   end
@@ -555,47 +556,47 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     child = @model1.children[1]
 
     child_view = child_viewmodel_class.new(child).to_hash
-    child_view["name"] = "changed"
+    child_view['name'] = 'changed'
 
-    view = { "_type" => "Model",
-             "name" => "new_p",
-             "children" => [child_view, { "_type" => "Child", "name" => "new" }]}
+    view = { '_type' => 'Model',
+             'name' => 'new_p',
+             'children' => [child_view, { '_type' => 'Child', 'name' => 'new' }] }
 
-    # TODO this is as awkward here as it is in the application
-    release_view = { "_type" => "Model",
-                     "id" => @model1.id,
-                     "children" => [{ "_type" => "Child", "id" => @model1.children[0].id },
-                                    { "_type" => "Child", "id" => @model1.children[2].id }]}
+    # TODO: this is as awkward here as it is in the application
+    release_view = { '_type' => 'Model',
+                     'id' => @model1.id,
+                     'children' => [{ '_type' => 'Child', 'id' => @model1.children[0].id },
+                                    { '_type' => 'Child', 'id' => @model1.children[2].id },] }
 
     pv = viewmodel_class.deserialize_from_view([view, release_view])
     new_parent = pv.first.model
 
     # child should be removed from old parent and positions updated
     @model1.reload
-    assert_equal(2, @model1.children.size, "database has 2 children")
+    assert_equal(2, @model1.children.size, 'database has 2 children')
     oc1, oc2 = @model1.children.order(:position)
-    assert_equal("p1c1", oc1.name, "database c1 unchanged")
-    assert_equal("p1c3", oc2.name, "database c2 unchanged")
+    assert_equal('p1c1', oc1.name, 'database c1 unchanged')
+    assert_equal('p1c3', oc2.name, 'database c2 unchanged')
 
     # child should be added to new parent with valid position
-    assert_equal(2, new_parent.children.size, "viewmodel has 2 children")
+    assert_equal(2, new_parent.children.size, 'viewmodel has 2 children')
     nc1, nc2 = new_parent.children.order(:position)
     assert_equal(child, nc1)
-    assert_equal("changed", nc1.name)
-    assert_equal("new", nc2.name)
+    assert_equal('changed', nc1.name)
+    assert_equal('new', nc2.name)
   end
 
   def test_move_and_edit_child_to_existing
     old_child = @model1.children[1]
 
     old_child_view = child_viewmodel_class.new(old_child).to_hash
-    old_child_view["name"] = "changed"
+    old_child_view['name'] = 'changed'
     view = viewmodel_class.new(@model2).to_hash
-    view["children"] << old_child_view
+    view['children'] << old_child_view
 
-    release_view = {"_type" => "Model", "id" => @model1.id,
-                    "children" => [{"_type" => "Child", "id" => @model1.children[0].id},
-                                   {"_type" => "Child", "id" => @model1.children[2].id}]}
+    release_view = { '_type' => 'Model', 'id' => @model1.id,
+                    'children' => [{ '_type' => 'Child', 'id' => @model1.children[0].id },
+                                   { '_type' => 'Child', 'id' => @model1.children[2].id },] }
 
     viewmodel_class.deserialize_from_view([view, release_view])
 
@@ -606,46 +607,46 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     assert_equal(2, @model1.children.size)
     oc1, oc2 = @model1.children.order(:position)
 
-    assert_equal("p1c1", oc1.name)
-    assert_equal("p1c3", oc2.name)
+    assert_equal('p1c1', oc1.name)
+    assert_equal('p1c3', oc2.name)
 
     # child should be added to new parent with valid position
     assert_equal(3, @model2.children.size)
     nc1, _, nc3 = @model2.children.order(:position)
-    assert_equal("p2c1", nc1.name)
+    assert_equal('p2c1', nc1.name)
 
-    assert_equal("p2c1", nc1.name)
+    assert_equal('p2c1', nc1.name)
 
     assert_equal(old_child, nc3)
-    assert_equal("changed", nc3.name)
+    assert_equal('changed', nc3.name)
   end
 
   def test_functional_update_append
     children_before = @model1.children.order(:position).pluck(:id)
     fupdate = build_fupdate do
       append([{ '_type' => 'Child' },
-              { '_type' => 'Child' }])
+              { '_type' => 'Child' },])
     end
 
-    append_view     = { '_type'    => 'Model',
+    append_view = { '_type' => 'Model',
                         'id'       => @model1.id,
                         'children' => fupdate }
 
-    result          = viewmodel_class.deserialize_from_view(append_view)
+    result = viewmodel_class.deserialize_from_view(append_view)
     @model1.reload
 
-    created_children = result.children[-2,2].map(&:id)
+    created_children = result.children[-2, 2].map(&:id)
 
     assert_equal(children_before + created_children,
                  @model1.children.order(:position).pluck(:id))
   end
 
   def test_functional_update_append_before_mid
-    c1, c2, c3  = @model1.children.order(:position)
+    c1, c2, c3 = @model1.children.order(:position)
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
+              { '_type' => 'Child', 'name' => 'new c2' },],
              before: { '_type' => 'Child', 'id' => c2.id })
     end
 
@@ -660,7 +661,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   end
 
   def test_functional_update_append_before_reorder
-    c1, c2, c3  = @model1.children.order(:position)
+    c1, c2, c3 = @model1.children.order(:position)
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'id' => c3.id }],
@@ -678,11 +679,11 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   end
 
   def test_functional_update_append_before_beginning
-    c1, c2, c3  = @model1.children.order(:position)
+    c1, c2, c3 = @model1.children.order(:position)
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
+              { '_type' => 'Child', 'name' => 'new c2' },],
              before: { '_type' => 'Child', 'id' => c1.id })
     end
 
@@ -702,7 +703,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
+              { '_type' => 'Child', 'name' => 'new c2' },],
              before: { '_type' => 'Child', 'id' => c2.id })
     end
 
@@ -715,11 +716,11 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   end
 
   def test_functional_update_append_after_mid
-    c1, c2, c3  = @model1.children.order(:position)
+    c1, c2, c3 = @model1.children.order(:position)
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
+              { '_type' => 'Child', 'name' => 'new c2' },],
              after: { '_type' => 'Child', 'id' => c2.id })
     end
 
@@ -734,12 +735,12 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   end
 
   def test_functional_update_append_after_end
-    c1, c2, c3  = @model1.children.order(:position)
+    c1, c2, c3 = @model1.children.order(:position)
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
-             after: { '_type' => 'Child', 'id' => c3.id, })
+              { '_type' => 'Child', 'name' => 'new c2' },],
+             after: { '_type' => 'Child', 'id' => c3.id })
     end
 
     append_view = { '_type'    => 'Model',
@@ -758,9 +759,9 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
     fupdate = build_fupdate do
       append([{ '_type' => 'Child', 'name' => 'new c1' },
-              { '_type' => 'Child', 'name' => 'new c2' }],
+              { '_type' => 'Child', 'name' => 'new c2' },],
              after: { '_type' => 'Child', 'id' => c2.id },
-             )
+            )
     end
 
     append_view = { '_type'    => 'Model',
@@ -778,7 +779,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
       remove([{ '_type' => 'Child', 'id' => c2_id }])
     end
 
-    remove_view         = { '_type'    => 'Model',
+    remove_view = { '_type' => 'Model',
                             'id'       => @model1.id,
                             'children' => fupdate }
     viewmodel_class.deserialize_from_view(remove_view)
@@ -788,7 +789,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
   end
 
   def test_functional_update_remove_failure
-    c_id        = @model1.children.pluck(:id).first
+    c_id = @model1.children.pluck(:id).first
 
     fupdate = build_fupdate do
       remove([{ '_type' => 'Child',
@@ -816,7 +817,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
                 'name'  => 'Functionally Updated Child' }])
     end
 
-    update_view         = { '_type'    => 'Model',
+    update_view = { '_type' => 'Model',
                             'id'       => @model1.id,
                             'children' => fupdate }
     viewmodel_class.deserialize_from_view(update_view)
@@ -866,7 +867,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
 
   describe 'owned reference children' do
     def child_attributes
-      super.merge(viewmodel: ->(v) { root! })
+      super.merge(viewmodel: ->(_v) { root! })
     end
 
     def new_model