iknow_view_models 2.8.4

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

@@ -0,0 +1,320 @@
+require_relative "../../../helpers/arvm_test_utilities.rb"
+require_relative "../../../helpers/arvm_test_models.rb"
+
+require "minitest/autorun"
+
+require "view_model/active_record"
+
+module ViewModel::ActiveRecord::PolyTest
+  ## Polymorphic pointer to parent in child (child may belong to different type parents)
+  class PolyParentPointerTest < ActiveSupport::TestCase
+    include ARVMTestUtilities
+    def before_all
+      super
+      build_viewmodel(:Child) do
+        define_schema do |t|
+          t.string  :text
+          t.string  :poly_type
+          t.integer :poly_id
+        end
+        define_model do
+          belongs_to :poly, polymorphic: true
+        end
+        define_viewmodel do
+          attributes :text
+        end
+      end
+
+      build_viewmodel(:PolyParentOne) do
+        define_schema do |t|
+          t.string :text
+        end
+        define_model do
+          has_one :grandparent, inverse_of: :poly_parent_one
+          has_one :child, as: :poly, dependent: :destroy, inverse_of: :poly
+        end
+        define_viewmodel do
+          attributes :text
+          association :child
+        end
+      end
+
+      build_viewmodel(:PolyParentTwo) do
+        define_schema do |t|
+          t.integer :num
+        end
+        define_model do
+          has_one :grandparent, inverse_of: :poly_parent_two
+          has_many :children, as: :poly, dependent: :destroy, inverse_of: :poly
+        end
+        define_viewmodel do
+          attributes :num
+          association :children
+        end
+      end
+
+      build_viewmodel(:Grandparent) do
+        define_schema do |t|
+          t.integer :poly_parent_one_id
+          t.integer :poly_parent_two_id
+        end
+        define_model do
+          belongs_to :poly_parent_one, dependent: :destroy, inverse_of: :grandparent
+          belongs_to :poly_parent_two, dependent: :destroy, inverse_of: :grandparent
+        end
+        define_viewmodel do
+          associations :poly_parent_one, :poly_parent_two
+        end
+      end
+    end
+
+    def setup
+      super
+      @parent1 = PolyParentOne.create(text: "p1", child: Child.new(text: "c1"))
+      @parent2 = PolyParentTwo.create(num: 2, children: [Child.new(text: "c2"), Child.new(text: "c3")])
+      @grandparent = Grandparent.create(poly_parent_one: @parent1, poly_parent_two: @parent2)
+      enable_logging!
+    end
+
+    def test_create_has_one_from_view
+      p1_view = {
+        "_type" => "PolyParentOne",
+        "text"  => "p",
+        "child" => { "_type" => "Child", "text" => "c" }
+      }
+      p1v = PolyParentOneView.deserialize_from_view(p1_view)
+      p1 = p1v.model
+
+      assert(p1.present?)
+      assert(p1.child.present?)
+      assert_equal(p1, p1.child.poly)
+    end
+
+    def test_create_has_many_from_view
+      p2_view = {
+        "_type" => "PolyParentTwo",
+        "num"   => "2",
+        "children" => [{ "_type" => "Child", "text" => "c1" }, { "_type" => "Child", "text" => "c2" }]
+      }
+      p2v = PolyParentTwoView.deserialize_from_view(p2_view)
+      p2 = p2v.model
+
+      assert(p2.present?)
+      assert(p2.children.count == 2)
+      p2.children.each do |c|
+        assert_equal(p2, c.poly)
+      end
+    end
+
+    def test_move
+      # test that I can move a child from one type to another and the parent pointer/type is correctly updated.
+      alter_by_view!(GrandparentView, @grandparent) do |view, refs|
+        c1 = view["poly_parent_one"]["child"]
+        c2 = view["poly_parent_two"]["children"].pop
+        view["poly_parent_one"]["child"] = c2
+        view["poly_parent_two"]["children"].push(c1)
+      end
+      @grandparent.reload
+      assert_equal("c3", @grandparent.poly_parent_one.child.text)
+      assert_equal(["c1","c2"], @grandparent.poly_parent_two.children.map(&:text).sort)
+    end
+  end
+
+  ## Polymorphic pointer to child in parent (multiple types of child)
+  class PolyChildPointerTest < ActiveSupport::TestCase
+    include ARVMTestUtilities
+    def self.build_poly_children(arvm_test_case)
+      arvm_test_case.build_viewmodel(:PolyOne) do
+        define_schema do |t|
+          t.integer :number
+        end
+
+        define_model do
+          has_one :parent, as: :poly
+        end
+
+        define_viewmodel do
+          attributes :number
+        end
+      end
+
+      arvm_test_case.build_viewmodel(:PolyTwo) do
+        define_schema do |t|
+          t.string :text
+        end
+
+        define_model do
+          has_one :parent, as: :poly
+        end
+
+        define_viewmodel do
+          attributes :text
+        end
+      end
+    end
+
+    def self.build_parent(arvm_test_case)
+      arvm_test_case.build_viewmodel(:Parent) do
+        define_schema do |t|
+          t.string :name
+          t.string :poly_type
+          t.integer :poly_id
+        end
+
+        define_model do
+          belongs_to :poly, polymorphic: true, dependent: :destroy, inverse_of: :parent
+        end
+
+        define_viewmodel do
+          attributes   :name
+          association :poly, viewmodels: [PolyOneView, PolyTwoView]
+        end
+      end
+    end
+
+
+    def before_all
+      super
+      self.class.build_poly_children(self)
+      self.class.build_parent(self)
+    end
+
+    def setup
+      super
+
+      @parent1 = Parent.create(name: "p1",
+                               poly: PolyOne.new(number: 1))
+
+      @parent2 = Parent.create(name: "p2")
+
+      enable_logging!
+    end
+
+    def test_loading_batching
+      Parent.create(name: "with PolyOne", poly: PolyOne.new)
+      Parent.create(name: "with PolyTwo", poly: PolyTwo.new)
+
+      log_queries do
+        serialize(ParentView.load)
+      end
+      assert_equal(['Parent Load', 'PolyOne Load', 'PolyTwo Load'],
+                   logged_load_queries.sort)
+    end
+
+    def test_create_from_view
+      view = {
+        "_type"    => "Parent",
+        "name"     => "p",
+        "poly"     => { "_type" => "PolyTwo", "text" => "pol" }
+      }
+
+      pv = ParentView.deserialize_from_view(view)
+      p = pv.model
+
+      assert(!p.changed?)
+      assert(!p.new_record?)
+
+      assert_equal("p", p.name)
+
+      assert(p.poly.present?)
+      assert(p.poly.is_a?(PolyTwo))
+      assert_equal("pol", p.poly.text)
+    end
+
+
+    def test_serialize_view
+      view, _refs = serialize_with_references(ParentView.new(@parent1))
+
+      assert_equal({ "_type"    => "Parent",
+                     "_version" => 1,
+                     "id"       => @parent1.id,
+                     "name"     => @parent1.name,
+                     "poly"     => { "_type"    => @parent1.poly_type,
+                                     "_version" => 1,
+                                     "id"       => @parent1.poly.id,
+                                     "number"   => @parent1.poly.number }
+                   },
+                   view)
+    end
+
+    # TODO(review): is this test worth keeping?
+    def test_invalid_type_lookup_with_version
+      ex = assert_raises do
+        ParentView.deserialize_from_view(
+          { '_type' => 'Parent',
+            '_new'  => true,
+            'poly' => {
+              '_type'    => 'SomethingThatsNotActuallyAType',
+              '_version' => 1,
+            } })
+        end
+        assert_match(/\binvalid\b.+\bviewmodel type\b/i, ex.message)
+    end
+
+    def test_change_polymorphic_type
+      old_poly = @parent1.poly
+
+      alter_by_view!(ParentView, @parent1) do |view, refs|
+        view['poly'] = { '_type' => 'PolyTwo', 'text' => 'hi' }
+      end
+
+      assert_instance_of(PolyTwo, @parent1.poly)
+      assert_equal(false, PolyOne.exists?(old_poly.id))
+    end
+
+    class RenameTest < ActiveSupport::TestCase
+      include ARVMTestUtilities
+
+      def before_all
+        super
+
+        ViewModel::ActiveRecord::PolyTest::PolyChildPointerTest.build_poly_children(self)
+
+        build_viewmodel(:Parent) do
+          define_schema do |t|
+            t.string :name
+            t.string :poly_type
+            t.integer :poly_id
+          end
+
+          define_model do
+            belongs_to :poly, polymorphic: true, dependent: :destroy, inverse_of: :parent
+          end
+
+          define_viewmodel do
+            attributes :name
+            association :poly, viewmodels: [PolyOneView, PolyTwoView], as: :something_else
+          end
+        end
+      end
+
+      def setup
+        super
+
+        @parent = Parent.create(poly: PolyOne.create(number: 42))
+
+        enable_logging!
+      end
+
+      def test_dependencies
+        root_updates, _ref_updates = ViewModel::ActiveRecord::UpdateData.parse_hashes([{ '_type' => 'Parent', 'something_else' => nil }])
+        assert_equal(DeepPreloader::Spec.new('poly' => DeepPreloader::PolymorphicSpec.new), root_updates.first.preload_dependencies)
+        assert_equal({ 'something_else' => {} }, root_updates.first.updated_associations)
+      end
+
+      def test_renamed_roundtrip
+        alter_by_view!(ParentView, @parent) do |view, refs|
+          assert_equal({ 'id'       => @parent.id,
+                         '_type'    => 'PolyOne',
+                         '_version' => 1,
+                         'number'   => 42 },
+                       view['something_else'])
+          view['something_else'] = {'_type' => 'PolyTwo', 'text' => 'hi'}
+        end
+
+        assert_equal('hi', @parent.poly.text)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,285 @@
+require_relative "../../../helpers/arvm_test_utilities.rb"
+require_relative "../../../helpers/arvm_test_models.rb"
+
+require "minitest/autorun"
+
+require "view_model/active_record"
+
+class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
+  include ARVMTestUtilities
+
+  module WithCategory
+    def before_all
+      super
+
+      build_viewmodel(:Category) do
+        define_schema do |t|
+          t.string :name
+        end
+
+        define_model do
+          has_many :parents
+        end
+
+        define_viewmodel do
+          attributes :name
+        end
+      end
+    end
+  end
+
+  module WithParent
+    def before_all
+      super
+
+      build_viewmodel(:Parent) do
+        define_schema do |t|
+          t.string :name
+          t.references :category, foreign_key: true # shared reference
+        end
+
+        define_model do
+          belongs_to :category
+        end
+
+        define_viewmodel do
+          attributes  :name
+          association :category, shared: true, optional: true
+        end
+      end
+    end
+  end
+
+  include WithCategory
+  include WithParent
+
+  def setup
+    super
+
+    @parent1 = Parent.create(name: "p1",
+                             category: Category.new(name: "p1cat"))
+
+    @parent2 = Parent.create(name: "p2")
+
+    @category1 = Category.create(name: "Cat1")
+
+    enable_logging!
+  end
+
+  def serialize_context
+    ParentView.new_serialize_context(include: :category)
+  end
+
+  def test_loading_batching
+    Parent.create(category: Category.new)
+
+    log_queries do
+      serialize(ParentView.load(serialize_context: serialize_context),
+                serialize_context: serialize_context)
+    end
+    assert_equal(['Parent Load', 'Category Load'],
+                 logged_load_queries)
+  end
+
+  def test_create_from_view
+    view = {
+      "_type"    => "Parent",
+      "name"     => "p",
+      "category"   => { "_ref" => "r1" },
+    }
+    refs = {
+      "r1" => { "_type" => "Category", "name" => "newcat"}
+    }
+
+    pv = ParentView.deserialize_from_view(view, references: refs)
+    p = pv.model
+
+    assert(!p.changed?)
+    assert(!p.new_record?)
+
+    assert_equal("p", p.name)
+
+    assert(p.category.present?)
+    assert_equal("newcat", p.category.name)
+  end
+
+  def test_serialize_view
+    view, refs = serialize_with_references(ParentView.new(@parent1), serialize_context: serialize_context)
+    cat1_ref = refs.detect { |_, v| v['_type'] == 'Category' }.first
+
+    assert_equal({cat1_ref => { '_type'    => "Category",
+                                "_version" => 1,
+                                'id'       => @parent1.category.id,
+                                'name'     => @parent1.category.name }},
+                 refs)
+
+    assert_equal({ "_type"    => "Parent",
+                   "_version" => 1,
+                   "id"       => @parent1.id,
+                   "name"     => @parent1.name,
+                   "category" => { "_ref" => cat1_ref } },
+                 view)
+  end
+
+  def test_shared_eager_include
+    parent_includes = ParentView.eager_includes
+
+    assert_equal(DeepPreloader::Spec.new, parent_includes)
+
+    extra_includes = ParentView.eager_includes(serialize_context: ParentView.new_serialize_context(include: :category))
+
+    assert_equal(DeepPreloader::Spec.new('category' => DeepPreloader::Spec.new), extra_includes)
+  end
+
+  def test_shared_serialize_interning
+    @parent2.update(category: @parent1.category)
+    view, refs = serialize_with_references([ParentView.new(@parent1),
+                                            ParentView.new(@parent2)],
+                                           serialize_context: ParentView.new_serialize_context(include: :category))
+
+    category_ref = view.first['category']['_ref']
+
+    assert_equal([category_ref], refs.keys,
+                 'category referenced twice generates a single reference')
+  end
+
+  def test_shared_add_reference
+    alter_by_view!(ParentView, @parent2, serialize_context: serialize_context) do |p2view, refs|
+      p2view['category'] = { '_ref' => 'myref' }
+      refs['myref'] = update_hash_for(CategoryView, @category1)
+    end
+
+    assert_equal(@category1, @parent2.category)
+  end
+
+  def test_shared_add_multiple_references
+    alter_by_view!(ParentView, [@parent1, @parent2], serialize_context: serialize_context) do |(p1view, p2view), refs|
+      refs.delete(p1view['category']['_ref'])
+      refs['myref'] = update_hash_for(CategoryView, @category1)
+
+      p1view['category'] = { '_ref' => 'myref' }
+      p2view['category'] = { '_ref' => 'myref' }
+    end
+
+    assert_equal(@category1, @parent1.category)
+    assert_equal(@category1, @parent2.category)
+  end
+
+  def test_shared_requires_all_references
+    ex = assert_raises(ViewModel::DeserializationError::InvalidStructure) do
+      alter_by_view!(ParentView, @parent2, serialize_context: serialize_context) do |p2view, refs|
+        refs['spurious_ref'] = { '_type' => 'Parent', 'id' => @parent1.id }
+      end
+    end
+    assert_match(/References not referred to from roots/, ex.message)
+  end
+
+  def test_shared_requires_valid_references
+    assert_raises(ViewModel::DeserializationError::InvalidSharedReference) do
+      serialize_context = ParentView.new_serialize_context(include: :category)
+      alter_by_view!(ParentView, @parent1, serialize_context: serialize_context) do |p1view, refs|
+        refs.clear # remove the expected serialized refs
+      end
+    end
+  end
+
+  def test_shared_requires_assignable_type
+    ex = assert_raises(ViewModel::DeserializationError::InvalidAssociationType) do
+      serialize_context = ParentView.new_serialize_context(include: :category)
+      alter_by_view!(ParentView, @parent1, serialize_context: serialize_context) do |p1view, refs|
+        p1view['category'] = { '_ref' => 'p2' }
+        refs['p2'] = update_hash_for(ParentView, @parent2)
+      end
+    end
+    assert_equal("category", ex.association)
+  end
+
+  def test_shared_requires_unique_references
+    serialize_context = ParentView.new_serialize_context(include: :category)
+    c1_ref = update_hash_for(CategoryView, @category1)
+    assert_raises(ViewModel::DeserializationError::DuplicateNodes) do
+      alter_by_view!(ParentView, [@parent1, @parent2], serialize_context: serialize_context) do |(p1view, p2view), refs|
+        refs['c_a'] = c1_ref.dup
+        refs['c_b'] = c1_ref.dup
+        p1view['category'] = { '_ref' => 'c_a' }
+        p2view['category'] = { '_ref' => 'c_b' }
+      end
+    end
+  end
+
+  def test_shared_updates_shared_data
+    serialize_context = ParentView.new_serialize_context(include: :category)
+    alter_by_view!(ParentView, @parent1, serialize_context: serialize_context) do |p1view, refs|
+      category_ref = p1view['category']['_ref']
+      refs[category_ref]['name'] = 'newcatname'
+    end
+    assert_equal('newcatname', @parent1.category.name)
+  end
+
+  def test_shared_delete_reference
+    serialize_context = ParentView.new_serialize_context(include: :category)
+    alter_by_view!(ParentView, @parent1, serialize_context: serialize_context) do |p1view, refs|
+      category_ref = p1view['category']['_ref']
+      refs.delete(category_ref)
+      p1view['category'] = nil
+    end
+    assert_nil(@parent1.category)
+    assert(Category.where(id: @category1.id).present?)
+  end
+
+  def test_child_edit_doesnt_editcheck_parent
+    serialize_context = ParentView.new_serialize_context(include: :category)
+    d_context = ParentView.new_deserialize_context
+
+    alter_by_view!(ParentView, @parent1, serialize_context: serialize_context, deserialize_context: d_context) do |view, refs|
+      refs[view['category']["_ref"]]["name"] = "changed"
+    end
+
+    assert(d_context.valid_edit_refs.include?(ViewModel::Reference.new(CategoryView, @parent1.category.id)))
+    refute(d_context.valid_edit_refs.include?(ViewModel::Reference.new(ParentView, @parent1.id)))
+  end
+
+  def test_child_change_editchecks_parent
+    s_context = ParentView.new_serialize_context(include: :category)
+
+    nv, d_context = alter_by_view!(ParentView, @parent1, serialize_context: s_context) do |view, refs|
+      refs.delete(view['category']['_ref'])
+      view['category']['_ref'] = 'new_cat'
+      refs['new_cat'] = { '_type' => 'Category', 'name' => 'new category' }
+    end
+
+    assert(d_context.valid_edit_refs.include?(nv.to_reference))
+    assert(d_context.valid_edit_refs.include?(nv.category.to_reference))
+  end
+
+  def test_child_delete_editchecks_parent
+    serialize_context = ParentView.new_serialize_context(include: :category)
+    d_context = ParentView.new_deserialize_context
+
+    alter_by_view!(ParentView, @parent1, serialize_context: serialize_context, deserialize_context: d_context) do |view, refs|
+      refs.delete(view['category']['_ref'])
+      view['category'] = nil
+    end
+
+    assert(d_context.valid_edit_refs.include?(ViewModel::Reference.new(ParentView, @parent1.id)))
+  end
+
+  def test_dependent_viewmodels
+    deps = ParentView.dependent_viewmodels
+    assert_equal([ParentView, CategoryView].to_set, deps)
+
+    deps = ParentView.dependent_viewmodels(include_shared: false)
+    assert_equal([ParentView].to_set, deps)
+  end
+
+  def test_deep_schema_version
+    vers = ParentView.deep_schema_version
+    assert_equal({ ParentView.view_name   => ParentView.schema_version,
+                   CategoryView.view_name => CategoryView.schema_version },
+                 vers)
+
+    vers = ParentView.deep_schema_version(include_shared: false)
+    assert_equal({ ParentView.view_name => ParentView.schema_version },
+                 vers)
+  end
+end