iknow_view_models 3.4.2 → 3.5.1

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

@@ -15,83 +15,19 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
   include ControllerTestModels
   include ControllerTestControllers
 
-  def visit(hook, view)
-    CallbackTracer::Visit.new(hook, view)
-  end
-
-  def each_hook_span(trace)
-    return enum_for(:each_hook_span, trace) unless block_given?
-
-    hook_nesting = []
-
-    trace.each_with_index do |t, i|
-      case t.hook
-      when ViewModel::Callbacks::Hook::OnChange,
-           ViewModel::Callbacks::Hook::BeforeValidate
-        # ignore
-      when ViewModel::Callbacks::Hook::BeforeVisit,
-           ViewModel::Callbacks::Hook::BeforeDeserialize
-        hook_nesting.push([t, i])
-
-      when ViewModel::Callbacks::Hook::AfterVisit,
-           ViewModel::Callbacks::Hook::AfterDeserialize
-        (nested_top, nested_index) = hook_nesting.pop
-
-        unless nested_top.hook.name == t.hook.name.sub(/^After/, 'Before')
-          raise "Invalid nesting, processing '#{t.hook.name}', expected matching '#{nested_top.hook.name}'"
-        end
-
-        unless nested_top.view == t.view
-          raise "Invalid nesting, processing '#{t.hook.name}', " \
-                  "expected viewmodel '#{t.view}' to match '#{nested_top.view}'"
-        end
-
-        yield t.view, (nested_index..i), t.hook.name.sub(/^After/, '')
-
-      else
-        raise 'Unexpected hook type'
-      end
-    end
-  end
-
-  def show_span(view, range, hook)
-    "#{view.class.name}(#{view.id}) #{range} #{hook}"
-  end
+  def before_all
+    super
 
-  def enclosing_hooks(spans, inner_range)
-    spans.select do |_view, range, _hook|
-      inner_range != range && range.cover?(inner_range.min) && range.cover?(inner_range.max)
-    end
+    build_controller_test_models
   end
 
-  def assert_all_hooks_nested_inside_parent_hook(trace)
-    spans = each_hook_span(trace).to_a
-
-    spans.reject { |view, _range, _hook| view.class == ParentView }.each do |view, range, hook|
-      enclosing_spans = enclosing_hooks(spans, range)
-
-      enclosing_parent_hook = enclosing_spans.detect do |other_view, _other_range, other_hook|
-        other_hook == hook && other_view.class == ParentView
-      end
-
-      next if enclosing_parent_hook
-
-      self_str      = show_span(view, range, hook)
-      enclosing_str = enclosing_spans.map { |ov, ora, oh| show_span(ov, ora, oh) }.join("\n")
-      assert_not_nil(
-        enclosing_parent_hook,
-        "Invalid nesting of hook: #{self_str}\nEnclosing hooks:\n#{enclosing_str}")
-    end
+  def visit(hook, view)
+    CallbackTracer::Visit.new(hook, view)
   end
 
   def setup
     super
-    @parent = Parent.create(name: 'p',
-                            children: [Child.new(name: 'c1', position: 1.0),
-                                       Child.new(name: 'c2', position: 2.0),],
-                            label: Label.new,
-                            target: Target.new)
-
+    @parent = make_parent
     @parent_view = ParentView.new(@parent)
 
     enable_logging!
@@ -317,296 +253,4 @@ class ViewModel::ActiveRecord::ControllerTest < ActiveSupport::TestCase
     assert_equal(404, parentcontroller.status)
   end
 
-  #### Controller for nested model
-
-  def test_nested_collection_index_associated
-    _distractor = Parent.create(name: 'p2', children: [Child.new(name: 'c3', position: 1)])
-
-    childcontroller = ChildController.new(params: { parent_id: @parent.id })
-    childcontroller.invoke(:index_associated)
-
-    assert_equal(200, childcontroller.status)
-
-    expected_children = @parent.children
-    assert_equal({ 'data' => expected_children.map { |c| ChildView.new(c).to_hash } },
-                 childcontroller.hash_response)
-
-    assert_all_hooks_nested_inside_parent_hook(childcontroller.hook_trace)
-  end
-
-  def test_nested_collection_index
-    distractor = Parent.create(name: 'p2', children: [Child.new(name: 'c3', position: 1)])
-    childcontroller = ChildController.new
-
-    childcontroller.invoke(:index)
-
-    assert_equal(200, childcontroller.status)
-
-    expected_children = @parent.children + distractor.children
-    assert_equal({ 'data' => expected_children.map { |c| ChildView.new(c).to_hash } },
-                 childcontroller.hash_response)
-  end
-
-  def test_nested_collection_append_one
-    data = { '_type' => 'Child', 'name' => 'c3' }
-    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], @parent.children.order(:position).pluck(:name))
-    assert_equal({ 'data' => ChildView.new(@parent.children.last).to_hash },
-                 childcontroller.hash_response)
-
-    assert_all_hooks_nested_inside_parent_hook(childcontroller.hook_trace)
-  end
-
-  def test_nested_collection_append_many
-    data = [{ '_type' => 'Child', 'name' => 'c3' },
-            { '_type' => 'Child', 'name' => 'c4' },]
-
-    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({ 'data' => new_children_hashes },
-                 childcontroller.hash_response)
-
-    assert_all_hooks_nested_inside_parent_hook(childcontroller.hook_trace)
-  end
-
-  # FIXME: nested controllers really need to be to other roots; children aren't roots.
-  def test_nested_collection_replace
-    # Parent.children
-    old_children = @parent.children
-
-    data = [{ '_type' => 'Child', 'name' => 'newc1' },
-            { '_type' => 'Child', 'name' => 'newc2' },]
-
-    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_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(params: { parent_id: @parent.id, data: data })
-
-    childcontroller.invoke(:replace)
-
-    assert_equal(400, childcontroller.status)
-
-    assert_all_hooks_nested_inside_parent_hook(childcontroller.hook_trace)
-  end
-
-  def test_nested_collection_disassociate_one
-    old_child = @parent.children.first
-    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_predicate(Child.where(id: old_child.id), :empty?)
-
-    assert_all_hooks_nested_inside_parent_hook(childcontroller.hook_trace)
-  end
-
-  def test_nested_collection_disassociate_many
-    old_children = @parent.children
-
-    childcontroller = ChildController.new(params: { parent_id: @parent.id })
-    childcontroller.invoke(:disassociate_all)
-
-    assert_equal(200, childcontroller.status, childcontroller.hash_response)
-
-    @parent.reload
-
-    assert_predicate(@parent.children, :empty?)
-    assert_predicate(Child.where(id: old_children.map(&:id)), :empty?)
-
-    assert_all_hooks_nested_inside_parent_hook(childcontroller.hook_trace)
-  end
-
-  # direct methods on nested controller
-  def test_nested_collection_destroy
-    old_child = @parent.children.first
-    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_predicate(Child.where(id: old_child.id), :empty?)
-  end
-
-  def test_nested_collection_update
-    old_child = @parent.children.first
-
-    data = { 'id' => old_child.id,
-             '_type' => 'Child',
-             'name' => 'new_name' }
-
-    childcontroller = ChildController.new(params: { data: data })
-    childcontroller.invoke(:create)
-
-    assert_equal(200, childcontroller.status, childcontroller.hash_response)
-
-    old_child.reload
-
-    assert_equal('new_name', old_child.name)
-    assert_equal({ 'data' => ChildView.new(old_child).to_hash },
-                 childcontroller.hash_response)
-  end
-
-  def test_nested_collection_show
-    old_child = @parent.children.first
-
-    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
-
-  ## Single association
-
-  def test_nested_singular_replace_from_parent
-    old_label = @parent.label
-
-    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)
-
-    @parent.reload
-
-    assert_equal({ 'data' => { '_type'    => 'Label',
-                               '_version' => 1,
-                               'id'       => @parent.label.id,
-                               'text'     => 'new label' } },
-                 labelcontroller.hash_response)
-
-    refute_equal(old_label, @parent.label)
-    assert_equal('new label', @parent.label.text)
-
-    assert_all_hooks_nested_inside_parent_hook(labelcontroller.hook_trace)
-  end
-
-  def test_nested_singular_show_from_parent
-    old_label = @parent.label
-
-    labelcontroller = LabelController.new(params: { parent_id: @parent.id })
-    labelcontroller.invoke(:show_associated)
-
-    assert_equal(200, labelcontroller.status, labelcontroller.hash_response)
-
-    assert_equal({ 'data' => LabelView.new(old_label).to_hash },
-                 labelcontroller.hash_response)
-
-    assert_all_hooks_nested_inside_parent_hook(labelcontroller.hook_trace)
-  end
-
-  def test_nested_singular_destroy_from_parent
-    old_label = @parent.label
-
-    labelcontroller = LabelController.new(params: { parent_id: @parent.id })
-    labelcontroller.invoke(:destroy_associated)
-
-    @parent.reload
-
-    assert_equal(200, labelcontroller.status, labelcontroller.hash_response)
-    assert_equal({ 'data' => nil }, labelcontroller.hash_response)
-
-    assert_nil(@parent.label)
-    assert_predicate(Label.where(id: old_label.id), :empty?)
-
-    assert_all_hooks_nested_inside_parent_hook(labelcontroller.hook_trace)
-  end
-
-  def test_nested_singular_update_from_parent
-    old_label = @parent.label
-
-    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)
-
-    old_label.reload
-
-    assert_equal('new label', old_label.text)
-    assert_equal({ 'data' => LabelView.new(old_label).to_hash },
-                 labelcontroller.hash_response)
-
-    assert_all_hooks_nested_inside_parent_hook(labelcontroller.hook_trace)
-  end
-
-  def test_nested_singular_show_from_id
-    old_label = @parent.label
-
-    labelcontroller = LabelController.new(params: { id: old_label.id })
-    labelcontroller.invoke(:show)
-
-    assert_equal(200, labelcontroller.status, labelcontroller.hash_response)
-
-    assert_equal({ 'data' => LabelView.new(old_label).to_hash },
-                 labelcontroller.hash_response)
-  end
-
-  def test_nested_singular_destroy_from_id
-    # can't directly destroy pointed-to label that's referenced from parent:
-    # foreign key violation. Destroy target instead.
-    old_target = @parent.target
-
-    targetcontroller = TargetController.new(params: { id: old_target.id })
-    targetcontroller.invoke(:destroy)
-
-    @parent.reload
-
-    assert_equal(200, targetcontroller.status, targetcontroller.hash_response)
-    assert_equal({ 'data' => nil }, targetcontroller.hash_response)
-
-    assert_nil(@parent.target)
-    assert_predicate(Target.where(id: old_target.id), :empty?)
-  end
-
-  def test_nested_singular_update
-    old_label = @parent.label
-
-    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)
-
-    old_label.reload
-
-    assert_equal('new label', old_label.text)
-    assert_equal({ 'data' => LabelView.new(old_label).to_hash },
-                 labelcontroller.hash_response)
-  end
 end

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

@@ -195,8 +195,8 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
       update([{ '_type' => 'Child', 'id' => old_children.first.id, 'name' => 'renamed p1c1' }])
     end
 
-    nc = pv.replace_associated(:children, update, deserialize_context: context)
-    new_child = nc.detect { |c| c.name == 'new_child' }
+    updated = pv.replace_associated(:children, update, deserialize_context: context)
+    new_child = updated.detect { |c| c.name == 'new_child' }
 
     expected_edit_checks = [pv.to_reference,
                             ViewModel::Reference.new(child_viewmodel_class, new_child.id),
@@ -206,8 +206,11 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     assert_contains_exactly(expected_edit_checks,
                             context.valid_edit_refs)
 
-    assert_equal(3, nc.size)
-    assert_equal('renamed p1c1', nc[0].name)
+    assert_equal(2, updated.size)
+    assert_contains_exactly(
+      ['renamed p1c1', 'new_child'],
+      updated.map(&:name),
+    )
 
     @model1.reload
     assert_equal(['renamed p1c1', 'p1c2', 'new_child'], @model1.children.order(:position).map(&:name))
@@ -972,7 +975,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
         'children' => [
           { '_type' => 'Dog', 'dog_number' => 1 },
           { '_type' => 'Cat', 'cat_number' => 2 },
-        ]
+        ],
       }
 
       pv = ModelView.deserialize_from_view(view)
@@ -1010,7 +1013,7 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     it 'functional updates' do
       model = create_model!
 
-      alter_by_view!(ModelView, model) do |view, refs|
+      alter_by_view!(ModelView, model) do |view, _refs|
         view['children'] = build_fupdate do
           append([{ '_type' => 'Cat', 'cat_number' => 100 }])
         end
@@ -1021,6 +1024,18 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
       assert_kind_of(Cat, new_child)
       assert_equal(100, new_child.cat_number)
     end
+
+    it 'calculates eager_includes' do
+      includes = viewmodel_class.eager_includes
+      expected = DeepPreloader::Spec.new(
+        'children' => DeepPreloader::PolymorphicSpec.new(
+          {
+            'Dog' => DeepPreloader::Spec.new,
+            'Cat' => DeepPreloader::Spec.new,
+          }))
+
+      assert_equal(includes, expected)
+    end
   end
 
   describe 'owned reference children' do
@@ -1285,7 +1300,9 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
       it 'replaces children' do
         view = create_viewmodel!
         view.replace_associated(:children,
-                                [{ '_type' => 'Child', 'name' => 'newchildname' }])
+          [{ '_ref' => 'the_child' }],
+          references: { 'the_child' => { '_type' => 'Child', 'name' => 'newchildname' } }
+        )
 
         view.model.reload
 

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

@@ -438,19 +438,24 @@ class ViewModel::ActiveRecord::HasManyThroughTest < ActiveSupport::TestCase
     pv = ParentView.new(@parent1)
     context = ParentView.new_deserialize_context
 
-    nc = pv.replace_associated(:tags,
-                               [{ '_type' => 'Tag', 'name' => 'new_tag' }],
-                               deserialize_context: context)
+    data = [{ ViewModel::REFERENCE_ATTRIBUTE => 'tag1' }]
+    references = { 'tag1' => { '_type' => 'Tag', 'name' => 'new_tag' } }
+
+    updated = pv.replace_associated(:tags,
+      data, references: references,
+      deserialize_context: context)
+
+    post_children = ParentView.new(Parent.find(@parent1.id))._read_association(:tags)
 
     expected_edit_checks = [pv.to_reference,
-                            *nc.map(&:to_reference),]
+                            *post_children.map(&:to_reference),]
 
     assert_contains_exactly(expected_edit_checks,
                             context.valid_edit_refs)
 
-    assert_equal(1, nc.size)
-    assert(nc[0].is_a?(TagView))
-    assert_equal('new_tag', nc[0].name)
+    assert_equal(1, updated.size)
+    assert(updated[0].is_a?(TagView))
+    assert_equal('new_tag', updated[0].name)
 
     @parent1.reload
     assert_equal(['new_tag'], tags(@parent1).map(&:name))
@@ -467,13 +472,19 @@ class ViewModel::ActiveRecord::HasManyThroughTest < ActiveSupport::TestCase
     tag2 = @tag2
 
     update = build_fupdate do
-      append([{ '_type' => 'Tag', 'name' => 'new_tag' }])
+      append([{ViewModel::REFERENCE_ATTRIBUTE => 'ref_new_tag'}])
       remove([{ '_type' => 'Tag', 'id' => tag2.id }])
-      update([{ '_type' => 'Tag', 'id' => tag1.id, 'name' => 'renamed tag1' }])
+      update([{ViewModel::REFERENCE_ATTRIBUTE => 'ref_tag1'}])
     end
 
-    nc = pv.replace_associated(:tags, update, deserialize_context: context)
-    new_tag = nc.detect { |t| t.name == 'new_tag' }
+    references = {
+      'ref_new_tag' => { '_type' => 'Tag', 'name' => 'new_tag' },
+      'ref_tag1' => { '_type' => 'Tag', 'id' => tag1.id, 'name' => 'renamed tag1' },
+    }
+
+    updated = pv.replace_associated(:tags, update, references: references, deserialize_context: context)
+    post_children = ParentView.new(Parent.find(@parent1.id))._read_association(:tags)
+    new_tag = post_children.detect { |t| t.name == 'new_tag' }
 
     expected_edit_checks = [ViewModel::Reference.new(ParentView, @parent1.id),
                             ViewModel::Reference.new(TagView, @tag1.id),
@@ -482,7 +493,12 @@ class ViewModel::ActiveRecord::HasManyThroughTest < ActiveSupport::TestCase
     assert_contains_exactly(expected_edit_checks,
                             context.valid_edit_refs)
 
-    assert_equal(2, nc.size)
+    assert_equal(2, post_children.size)
+    assert_equal(2, update.size)
+    assert_contains_exactly(
+      ['new_tag', 'renamed tag1'],
+      updated.map(&:name),
+    )
 
     @parent1.reload
     assert_equal(['renamed tag1', 'new_tag'], tags(@parent1).map(&:name))

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

@@ -178,6 +178,35 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
           end
         end
       end
+
+      describe 'with a functional update' do
+        # note that this wouldn't actually be deserializable as child is not a collection
+        def subject_data
+          data = super()
+          data['child'] = wrap_with_fupdate(data['child'])
+          data
+        end
+
+        def expected_result
+          data = super()
+          data['data']['child'] = wrap_with_fupdate(data['data']['child'])
+          data
+        end
+
+        def wrap_with_fupdate(child)
+          # The 'after' and remove shouldn't get changed in migration, even though it has _type: Child
+          build_fupdate do
+            append([child], after: { '_type' => 'Child', 'id' => 9999 })
+            update([child.deep_merge('id' => 8888)])
+            remove([{ '_type' => 'Child', 'id' => 7777 }])
+          end
+        end
+
+        it 'migrates' do
+          migrate!
+          assert_equal(expected_result, subject)
+        end
+      end
     end
   end
 

data/test/unit/view_model/traversal_context_test.rb

@@ -187,7 +187,21 @@ class ViewModel::TraversalContextTest < ActiveSupport::TestCase
         it 'traverses as expected in replace_associated' do
           ctx = vm_deserialize_context(viewmodel_class)
           replacement = subject_association.collection? ? [new_child_hash] : new_child_hash
-          vm.replace_associated(subject_association_name, replacement, deserialize_context: ctx)
+          references = {}
+
+          # Referenced collections need to be presented as is, _except_ for when they're owned, as
+          # this is special cased in NestedControllerBase#write_association (+_bulk) for
+          # convenience.
+          if subject_association.referenced? && !subject_association.owned?
+            replacement = ViewModel::Utils.wrap_one_or_many(replacement) do |replacements|
+              replacements.map!.with_index do |update, index|
+                references["ref#{index}"] = update
+                { ViewModel::REFERENCE_ATTRIBUTE => "ref#{index}" }
+              end
+            end
+          end
+
+          vm.replace_associated(subject_association_name, replacement, references: references, deserialize_context: ctx)
 
           expected = expected_parent_details
           expected = expected.merge(expected_children_details) unless subject_association.referenced?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iknow_view_models
 version: !ruby/object:Gem::Version
-  version: 3.4.2
+  version: 3.5.1
 platform: ruby
 authors:
 - iKnow Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-23 00:00:00.000000000 Z
+date: 2021-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.0.2
 - !ruby/object:Gem::Dependency
   name: iknow_cache
   requirement: !ruby/object:Gem::Requirement
@@ -362,7 +362,7 @@ dependencies:
         version: '0'
 description: ''
 email:
-- edge@iknow.jp
+- systems@iknow.jp
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -453,6 +453,7 @@ files:
 - test/unit/view_model/active_record/belongs_to_test.rb
 - test/unit/view_model/active_record/cache_test.rb
 - test/unit/view_model/active_record/cloner_test.rb
+- test/unit/view_model/active_record/controller_nested_test.rb
 - test/unit/view_model/active_record/controller_test.rb
 - test/unit/view_model/active_record/counter_test.rb
 - test/unit/view_model/active_record/customization_test.rb
@@ -514,6 +515,7 @@ test_files:
 - test/unit/view_model/active_record/belongs_to_test.rb
 - test/unit/view_model/active_record/cache_test.rb
 - test/unit/view_model/active_record/cloner_test.rb
+- test/unit/view_model/active_record/controller_nested_test.rb
 - test/unit/view_model/active_record/controller_test.rb
 - test/unit/view_model/active_record/counter_test.rb
 - test/unit/view_model/active_record/customization_test.rb