iknow_view_models 3.4.4 → 3.5.0

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))
@@ -1297,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))