iknow_view_models 3.1.8 → 3.2.4

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?)

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

@@ -1,14 +1,14 @@
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
 
-require "minitest/autorun"
+require 'minitest/autorun'
 require 'minitest/unit'
 require 'minitest/hooks'
 
-require "view_model"
-require "view_model/active_record"
+require 'view_model'
+require 'view_model/active_record'
 
-require_relative "../../../helpers/controller_test_helpers.rb"
-require_relative "../../../helpers/callback_tracer.rb"
+require_relative '../../../helpers/controller_test_helpers'
+require_relative '../../../helpers/callback_tracer'
 
 class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   include ARVMTestUtilities
@@ -88,7 +88,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
     super
     @parent = Parent.create(name: 'p',
                             children: [Child.new(name: 'c1', position: 1.0),
-                                       Child.new(name: 'c2', position: 2.0)],
+                                       Child.new(name: 'c2', position: 2.0),],
                             label: Label.new,
                             target: Target.new)
 
@@ -98,7 +98,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   end
 
   def test_show
-    parentcontroller = ParentController.new(id: @parent.id)
+    parentcontroller = ParentController.new(params: { id: @parent.id })
     parentcontroller.invoke(:show)
 
     assert_equal({ 'data' => @parent_view.to_hash },
@@ -109,8 +109,41 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
     assert_all_hooks_nested_inside_parent_hook(parentcontroller.hook_trace)
   end
 
+  def test_migrated_show
+    parentcontroller = ParentController.new(
+      params: { id: @parent.id },
+      headers: { 'X-ViewModel-Versions' => { ParentView.view_name => 1 }.to_json })
+
+    parentcontroller.invoke(:show)
+
+    expected_view = @parent_view.to_hash
+                      .except('name')
+                      .merge('old_name' => @parent.name,
+                             ViewModel::VERSION_ATTRIBUTE => 1,
+                             ViewModel::MIGRATED_ATTRIBUTE => true)
+
+    assert_equal({ 'data' => expected_view },
+                 parentcontroller.hash_response)
+
+    assert_equal(200, parentcontroller.status)
+
+    assert_all_hooks_nested_inside_parent_hook(parentcontroller.hook_trace)
+  end
+
+  def test_invalid_migration_header
+    parentcontroller = ParentController.new(
+      params: { id: @parent.id },
+      headers: { 'X-ViewModel-Versions' => 'not a json' })
+
+    parentcontroller.invoke(:show)
+    assert_equal(400, parentcontroller.status)
+    assert_match(/Invalid JSON/i,
+                 parentcontroller.hash_response['error']['detail'],
+                 'json error propagated')
+  end
+
   def test_index
-    p2      = Parent.create(name: "p2")
+    p2      = Parent.create(name: 'p2')
     p2_view = ParentView.new(p2)
 
     parentcontroller = ParentController.new
@@ -119,7 +152,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
     assert_equal(200, parentcontroller.status)
 
     assert_equal(parentcontroller.hash_response,
-                 { "data" => [@parent_view.to_hash, p2_view.to_hash] })
+                 { 'data' => [@parent_view.to_hash, p2_view.to_hash] })
 
     assert_all_hooks_nested_inside_parent_hook(parentcontroller.hook_trace)
   end
@@ -131,10 +164,10 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
         'label'    => { '_type' => 'Label', 'text' => 'l' },
         'target'   => { '_type' => 'Target', 'text' => 't' },
         'children' => [{ '_type' => 'Child', 'name' => 'c1' },
-                       { '_type' => 'Child', 'name' => 'c2' }]
+                       { '_type' => 'Child', 'name' => 'c2' },],
     }
 
-    parentcontroller = ParentController.new(data: data)
+    parentcontroller = ParentController.new(params: { data: data })
     parentcontroller.invoke(:create)
 
     assert_equal(200, parentcontroller.status)
@@ -148,15 +181,31 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
     assert_all_hooks_nested_inside_parent_hook(parentcontroller.hook_trace)
   end
 
+  def test_migrated_create
+    data = {
+      '_type'    => 'Parent',
+      '_version' => 1,
+      'old_name' => 'p2',
+    }
+
+    parentcontroller = ParentController.new(params: { data: data, versions: { ParentView.view_name => 1 } })
+    parentcontroller.invoke(:create)
+
+    assert_equal(200, parentcontroller.status)
+
+    p2 = Parent.where(name: 'p2').first
+    assert(p2.present?, 'p2 created')
+  end
+
   def test_create_empty
-    parentcontroller = ParentController.new(data: [])
+    parentcontroller = ParentController.new(params: { data: [] })
     parentcontroller.invoke(:create)
 
     assert_equal(400, parentcontroller.status)
   end
 
   def test_create_invalid
-    parentcontroller = ParentController.new(data: 42)
+    parentcontroller = ParentController.new(params: { data: 42 })
     parentcontroller.invoke(:create)
 
     assert_equal(400, parentcontroller.status)
@@ -167,7 +216,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
              '_type' => 'Parent',
              'name'  => 'new' }
 
-    parentcontroller = ParentController.new(id: @parent.id, data: data)
+    parentcontroller = ParentController.new(params: { id: @parent.id, data: data })
     parentcontroller.invoke(:create)
 
     assert_equal(200, parentcontroller.status)
@@ -182,7 +231,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   end
 
   def test_destroy
-    parentcontroller = ParentController.new(id: @parent.id)
+    parentcontroller = ParentController.new(params: { id: @parent.id })
     parentcontroller.invoke(:destroy)
 
     assert_equal(200, parentcontroller.status)
@@ -196,7 +245,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   end
 
   def test_show_missing
-    parentcontroller = ParentController.new(id: 9999)
+    parentcontroller = ParentController.new(params: { id: 9999 })
     parentcontroller.invoke(:show)
 
     assert_equal(404, parentcontroller.status)
@@ -206,10 +255,10 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
                      'status' => 404,
                      'detail' => "Couldn't find Parent(s) with id(s)=[9999]",
                      'title' => nil,
-                     'code'   => "DeserializationError.NotFound",
-                     'meta' => { 'nodes' => [{ '_type' => "Parent", 'id' => 9999 }]},
+                     'code' => 'DeserializationError.NotFound',
+                     'meta' => { 'nodes' => [{ '_type' => 'Parent', 'id' => 9999 }] },
                      'exception' => nil,
-                     'causes' => nil }},
+                     'causes' => nil } },
                  parentcontroller.hash_response)
   end
 
@@ -218,7 +267,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
              'children' => [{ '_type' => 'Child',
                               'age'   => 42 }] }
 
-    parentcontroller = ParentController.new(data: data)
+    parentcontroller = ParentController.new(params: { data: data })
     parentcontroller.invoke(:create)
 
     assert_equal({ 'error' => {
@@ -227,13 +276,13 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
                      'status' => 400,
                      'detail' => 'Validation failed: \'age\' must be less than 42',
                      'title' => nil,
-                     'code'   => "DeserializationError.Validation",
-                     'meta' => { 'nodes' => [{ '_type' => "Child", 'id' => nil }],
+                     'code' => 'DeserializationError.Validation',
+                     'meta' => { 'nodes' => [{ '_type' => 'Child', 'id' => nil }],
                                  'attribute' => 'age',
                                  'message' => 'must be less than 42',
-                                 'details' => { 'error' => 'less_than', 'value' => 42, 'count' => 42 }},
+                                 'details' => { 'error' => 'less_than', 'value' => 42, 'count' => 42 } },
                      'exception' => nil,
-                     'causes' => nil }},
+                     'causes' => nil } },
                  parentcontroller.hash_response)
   end
 
@@ -241,17 +290,17 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
     data = { '_type'    => 'Parent',
              'children' => [{ '_type' => 'Child',
                               'age'   => 1 }] }
-    parentcontroller = ParentController.new(data: data)
+    parentcontroller = ParentController.new(params: { data: data })
     parentcontroller.invoke(:create)
 
     assert_equal(400, parentcontroller.status)
-    assert_match(%r{check constraint}i,
-                 parentcontroller.hash_response["error"]["detail"],
-                 "Database error propagated")
+    assert_match(/check constraint/i,
+                 parentcontroller.hash_response['error']['detail'],
+                 'Database error propagated')
   end
 
   def test_destroy_missing
-    parentcontroller = ParentController.new(id: 9999)
+    parentcontroller = ParentController.new(params: { id: 9999 })
     parentcontroller.invoke(:destroy)
 
     assert_equal({ 'error' => {
@@ -260,8 +309,8 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
                      'status' => 404,
                      'detail' => "Couldn't find Parent(s) with id(s)=[9999]",
                      'title' => nil,
-                     'code'   => "DeserializationError.NotFound",
-                     'meta' => { "nodes" => [{"_type" => "Parent", "id" => 9999 }] },
+                     'code' => 'DeserializationError.NotFound',
+                     'meta' => { 'nodes' => [{ '_type' => 'Parent', 'id' => 9999 }] },
                      'exception' => nil,
                      'causes' => nil } },
                  parentcontroller.hash_response)
@@ -273,7 +322,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   def test_nested_collection_index_associated
     _distractor = Parent.create(name: 'p2', children: [Child.new(name: 'c3', position: 1)])
 
-    childcontroller = ChildController.new(parent_id: @parent.id)
+    childcontroller = ChildController.new(params: { parent_id: @parent.id })
     childcontroller.invoke(:index_associated)
 
     assert_equal(200, childcontroller.status)
@@ -300,7 +349,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
 
   def test_nested_collection_append_one
     data = { '_type' => 'Child', 'name' => 'c3' }
-    childcontroller = ChildController.new(parent_id: @parent.id, data: data)
+    childcontroller = ChildController.new(params: { parent_id: @parent.id, data: data })
 
     childcontroller.invoke(:append)
 
@@ -308,7 +357,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
 
     @parent.reload
 
-    assert_equal(%w{c1 c2 c3}, @parent.children.order(:position).pluck(:name))
+    assert_equal(%w[c1 c2 c3], @parent.children.order(:position).pluck(:name))
     assert_equal({ 'data' => ChildView.new(@parent.children.last).to_hash },
                  childcontroller.hash_response)
 
@@ -317,17 +366,17 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
 
   def test_nested_collection_append_many
     data = [{ '_type' => 'Child', 'name' => 'c3' },
-            { '_type' => 'Child', 'name' => 'c4' }]
+            { '_type' => 'Child', 'name' => 'c4' },]
 
-    childcontroller = ChildController.new(parent_id: @parent.id, data: data)
+    childcontroller = ChildController.new(params: { parent_id: @parent.id, data: data })
     childcontroller.invoke(:append)
 
     assert_equal(200, childcontroller.status, childcontroller.hash_response)
 
     @parent.reload
 
-    assert_equal(%w{c1 c2 c3 c4}, @parent.children.order(:position).pluck(:name))
-    new_children_hashes = @parent.children.last(2).map{ |c| ChildView.new(c).to_hash }
+    assert_equal(%w[c1 c2 c3 c4], @parent.children.order(:position).pluck(:name))
+    new_children_hashes = @parent.children.last(2).map { |c| ChildView.new(c).to_hash }
     assert_equal({ 'data' => new_children_hashes },
                  childcontroller.hash_response)
 
@@ -339,25 +388,25 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
     # Parent.children
     old_children = @parent.children
 
-    data = [{'_type' => 'Child', 'name' => 'newc1'},
-            {'_type' => 'Child', 'name' => 'newc2'}]
+    data = [{ '_type' => 'Child', 'name' => 'newc1' },
+            { '_type' => 'Child', 'name' => 'newc2' },]
 
-    childcontroller = ChildController.new(parent_id: @parent.id, data: data)
+    childcontroller = ChildController.new(params: { parent_id: @parent.id, data: data })
     childcontroller.invoke(:replace)
 
     assert_equal(200, childcontroller.status, childcontroller.hash_response)
 
     @parent.reload
 
-    assert_equal(%w{newc1 newc2}, @parent.children.order(:position).pluck(:name))
+    assert_equal(%w[newc1 newc2], @parent.children.order(:position).pluck(:name))
     assert_predicate(Child.where(id: old_children.map(&:id)), :empty?)
 
     assert_all_hooks_nested_inside_parent_hook(childcontroller.hook_trace)
   end
 
   def test_nested_collection_replace_bad_data
-    data = [{ "name" => "nc" }]
-    childcontroller = ChildController.new(parent_id: @parent.id, data: data)
+    data = [{ 'name' => 'nc' }]
+    childcontroller = ChildController.new(params: { parent_id: @parent.id, data: data })
 
     childcontroller.invoke(:replace)
 
@@ -368,14 +417,14 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
 
   def test_nested_collection_disassociate_one
     old_child = @parent.children.first
-    childcontroller = ChildController.new(parent_id: @parent.id, id: old_child.id)
+    childcontroller = ChildController.new(params: { parent_id: @parent.id, id: old_child.id })
     childcontroller.invoke(:disassociate)
 
     assert_equal(200, childcontroller.status, childcontroller.hash_response)
 
     @parent.reload
 
-    assert_equal(%w{c2}, @parent.children.order(:position).pluck(:name))
+    assert_equal(%w[c2], @parent.children.order(:position).pluck(:name))
     assert_predicate(Child.where(id: old_child.id), :empty?)
 
     assert_all_hooks_nested_inside_parent_hook(childcontroller.hook_trace)
@@ -384,7 +433,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   def test_nested_collection_disassociate_many
     old_children = @parent.children
 
-    childcontroller = ChildController.new(parent_id: @parent.id)
+    childcontroller = ChildController.new(params: { parent_id: @parent.id })
     childcontroller.invoke(:disassociate_all)
 
     assert_equal(200, childcontroller.status, childcontroller.hash_response)
@@ -400,14 +449,14 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   # direct methods on nested controller
   def test_nested_collection_destroy
     old_child = @parent.children.first
-    childcontroller = ChildController.new(id: old_child.id)
+    childcontroller = ChildController.new(params: { id: old_child.id })
     childcontroller.invoke(:destroy)
 
     assert_equal(200, childcontroller.status, childcontroller.hash_response)
 
     @parent.reload
 
-    assert_equal(%w{c2}, @parent.children.order(:position).pluck(:name))
+    assert_equal(%w[c2], @parent.children.order(:position).pluck(:name))
     assert_predicate(Child.where(id: old_child.id), :empty?)
   end
 
@@ -418,7 +467,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
              '_type' => 'Child',
              'name' => 'new_name' }
 
-    childcontroller = ChildController.new(data: data)
+    childcontroller = ChildController.new(params: { data: data })
     childcontroller.invoke(:create)
 
     assert_equal(200, childcontroller.status, childcontroller.hash_response)
@@ -430,26 +479,25 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
                  childcontroller.hash_response)
   end
 
-   def test_nested_collection_show
+  def test_nested_collection_show
     old_child = @parent.children.first
 
-    childcontroller = ChildController.new(id: old_child.id)
+    childcontroller = ChildController.new(params: { id: old_child.id })
     childcontroller.invoke(:show)
 
     assert_equal({ 'data' => ChildView.new(old_child).to_hash },
                  childcontroller.hash_response)
 
     assert_equal(200, childcontroller.status)
-   end
-
+  end
 
   ## Single association
 
   def test_nested_singular_replace_from_parent
     old_label = @parent.label
 
-    data = {'_type' => 'Label', 'text' => 'new label'}
-    labelcontroller = LabelController.new(parent_id: @parent.id, data: data)
+    data = { '_type' => 'Label', 'text' => 'new label' }
+    labelcontroller = LabelController.new(params: { parent_id: @parent.id, data: data })
     labelcontroller.invoke(:create_associated)
 
     assert_equal(200, labelcontroller.status, labelcontroller.hash_response)
@@ -471,7 +519,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   def test_nested_singular_show_from_parent
     old_label = @parent.label
 
-    labelcontroller = LabelController.new(parent_id: @parent.id)
+    labelcontroller = LabelController.new(params: { parent_id: @parent.id })
     labelcontroller.invoke(:show_associated)
 
     assert_equal(200, labelcontroller.status, labelcontroller.hash_response)
@@ -485,7 +533,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   def test_nested_singular_destroy_from_parent
     old_label = @parent.label
 
-    labelcontroller = LabelController.new(parent_id: @parent.id)
+    labelcontroller = LabelController.new(params: { parent_id: @parent.id })
     labelcontroller.invoke(:destroy_associated)
 
     @parent.reload
@@ -502,8 +550,8 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   def test_nested_singular_update_from_parent
     old_label = @parent.label
 
-    data = {'_type' => 'Label', 'id' => old_label.id, 'text' => 'new label'}
-    labelcontroller = LabelController.new(parent_id: @parent.id, data: data)
+    data = { '_type' => 'Label', 'id' => old_label.id, 'text' => 'new label' }
+    labelcontroller = LabelController.new(params: { parent_id: @parent.id, data: data })
     labelcontroller.invoke(:create_associated)
 
     assert_equal(200, labelcontroller.status, labelcontroller.hash_response)
@@ -520,7 +568,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   def test_nested_singular_show_from_id
     old_label = @parent.label
 
-    labelcontroller = LabelController.new(id: old_label.id)
+    labelcontroller = LabelController.new(params: { id: old_label.id })
     labelcontroller.invoke(:show)
 
     assert_equal(200, labelcontroller.status, labelcontroller.hash_response)
@@ -534,7 +582,7 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
     # foreign key violation. Destroy target instead.
     old_target = @parent.target
 
-    targetcontroller = TargetController.new(id: old_target.id)
+    targetcontroller = TargetController.new(params: { id: old_target.id })
     targetcontroller.invoke(:destroy)
 
     @parent.reload
@@ -549,8 +597,8 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   def test_nested_singular_update
     old_label = @parent.label
 
-    data = {'_type' => 'Label', 'id' => old_label.id, 'text' => 'new label'}
-    labelcontroller = LabelController.new(data: data)
+    data = { '_type' => 'Label', 'id' => old_label.id, 'text' => 'new label' }
+    labelcontroller = LabelController.new(params: { data: data })
     labelcontroller.invoke(:create)
 
     assert_equal(200, labelcontroller.status, labelcontroller.hash_response)