iknow_view_models 2.8.4

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

@@ -0,0 +1,35 @@
+require_relative "../../../helpers/arvm_test_utilities.rb"
+require_relative "../../../helpers/arvm_test_models.rb"
+require_relative "../../../helpers/viewmodel_spec_helpers.rb"
+
+require "minitest/autorun"
+
+require "view_model/active_record"
+
+class ViewModel::ActiveRecord::Alias < ActiveSupport::TestCase
+  include ARVMTestUtilities
+  extend Minitest::Spec::DSL
+
+  include ViewModelSpecHelpers::ParentAndBelongsToChild
+
+  def child_attributes
+    super.merge(
+      viewmodel: ->(v) do
+        add_view_alias "ChildA"
+        add_view_alias "ChildB"
+      end
+    )
+  end
+
+  it "permits association types to be aliased" do
+    %w(Child ChildA ChildB).each do |view_alias|
+      view = {
+        "_type" => viewmodel_class.view_name,
+        "child" => { "_type" => view_alias },
+      }
+
+      parent = viewmodel_class.deserialize_from_view(view).model
+      assert_instance_of(child_model_class, parent.child)
+    end
+  end
+end

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

@@ -0,0 +1,376 @@
+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::BelongsToTest < ActiveSupport::TestCase
+  include ARVMTestUtilities
+
+  module WithLabel
+    def before_all
+      super
+
+      build_viewmodel(:Label) do
+        define_schema do |t|
+          t.string :text
+        end
+
+        define_model do
+          has_one :parent, inverse_of: :label
+        end
+
+        define_viewmodel do
+          attributes :text
+        end
+      end
+    end
+  end
+
+  module WithParent
+    def before_all
+      super
+
+      build_viewmodel(:Parent) do
+        define_schema do |t|
+          t.string :name
+          t.references :label, foreign_key: true
+        end
+
+        define_model do
+          belongs_to :label, inverse_of: :parent, dependent: :destroy
+        end
+
+        define_viewmodel do
+          attributes   :name
+          associations :label
+        end
+      end
+    end
+  end
+
+  module WithOwner
+    def before_all
+      super
+
+      build_viewmodel(:Owner) do
+        define_schema do |t|
+          t.integer :deleted_id
+          t.integer :ignored_id
+        end
+
+        define_model do
+          belongs_to :deleted, class_name: Label.name, dependent: :delete
+          belongs_to :ignored, class_name: Label.name
+        end
+
+        define_viewmodel do
+          associations :deleted, :ignored
+        end
+      end
+    end
+  end
+
+  include WithLabel
+  include WithParent
+
+  def setup
+    super
+
+    # TODO make a `has_list?` that allows a parent to set all children as an array
+    @parent1 = Parent.new(name: "p1",
+                          label: Label.new(text: "p1l"))
+    @parent1.save!
+
+    @parent2 = Parent.new(name: "p2",
+                          label: Label.new(text: "p2l"))
+
+    @parent2.save!
+
+    enable_logging!
+  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,
+                   "label"    => { "_type"    => "Label",
+                                   "_version" => 1,
+                                   "id"       => @parent1.label.id,
+                                   "text"     => @parent1.label.text },
+                 },
+                 view)
+  end
+
+  def test_loading_batching
+    log_queries do
+      serialize(ParentView.load)
+    end
+
+    assert_equal(['Parent Load', 'Label Load'],
+                 logged_load_queries)
+  end
+
+  def test_create_from_view
+    view = {
+      "_type"    => "Parent",
+      "name"     => "p",
+      "label"    => { "_type" => "Label", "text" => "l" },
+    }
+
+    pv = ParentView.deserialize_from_view(view)
+    p = pv.model
+
+    assert(!p.changed?)
+    assert(!p.new_record?)
+
+    assert_equal("p", p.name)
+
+    assert(p.label.present?)
+    assert_equal("l", p.label.text)
+  end
+
+  def test_create_belongs_to_nil
+    view = { '_type' => 'Parent', 'name' => 'p', 'label' => nil }
+    pv = ParentView.deserialize_from_view(view)
+    assert_nil(pv.model.label)
+  end
+
+  def test_create_invalid_child_type
+    view = { '_type' => 'Parent', 'name' => 'p', 'label' => { '_type' => 'Parent', 'name' => 'q' } }
+    assert_raises(ViewModel::DeserializationError::InvalidAssociationType) do
+      ParentView.deserialize_from_view(view)
+    end
+  end
+
+  def test_belongs_to_create
+    @parent1.update(label: nil)
+
+    alter_by_view!(ParentView, @parent1) do |view, refs|
+      view['label'] = { '_type' => 'Label', 'text' => 'cheese' }
+    end
+
+    assert_equal('cheese', @parent1.label.text)
+  end
+
+  def test_belongs_to_replace
+    old_label = @parent1.label
+
+    alter_by_view!(ParentView, @parent1) do |view, refs|
+      view['label'] = { '_type' => 'Label', 'text' => 'cheese' }
+    end
+
+    assert_equal('cheese', @parent1.label.text)
+    assert(Label.where(id: old_label).blank?)
+  end
+
+  def test_belongs_to_move_and_replace
+    old_p1_label = @parent1.label
+    old_p2_label = @parent2.label
+
+    set_by_view!(ParentView, [@parent1, @parent2]) do |(p1, p2), refs|
+      p1['label'] = nil
+      p2['label'] = update_hash_for(LabelView, old_p1_label)
+    end
+
+    assert(@parent1.label.blank?, 'l1 label reference removed')
+    assert_equal(old_p1_label, @parent2.label, 'p2 has label from p1')
+    assert(Label.where(id: old_p2_label).blank?, 'p2 old label deleted')
+  end
+
+  def test_belongs_to_swap
+    old_p1_label = @parent1.label
+    old_p2_label = @parent2.label
+
+    alter_by_view!(ParentView, [@parent1, @parent2]) do |(p1, p2), refs|
+      p1['label'] = update_hash_for(LabelView, old_p2_label)
+      p2['label'] = update_hash_for(LabelView, old_p1_label)
+    end
+
+    assert_equal(old_p2_label, @parent1.label, 'p1 has label from p2')
+    assert_equal(old_p1_label, @parent2.label, 'p2 has label from p1')
+  end
+
+  def test_moved_child_is_not_delete_checked
+    # move from p1 to p3
+    d_context = ParentView.new_deserialize_context
+
+    target_label = Label.create
+    from_parent  = Parent.create(name: 'from', label: target_label)
+    to_parent    = Parent.create(name: 'p3')
+
+    alter_by_view!(
+      ParentView, [from_parent, to_parent],
+      deserialize_context: d_context
+    ) do |(from, to), refs|
+      from['label'] = nil
+      to['label']   = update_hash_for(LabelView, target_label)
+    end
+
+    assert_equal(target_label, to_parent.label, 'target label moved')
+    assert_equal([ViewModel::Reference.new(ParentView, from_parent.id),
+                  ViewModel::Reference.new(ParentView, to_parent.id)],
+                 d_context.valid_edit_refs,
+                 "only parents are checked for change; child was not")
+  end
+
+  def test_implicit_release_invalid_belongs_to
+    taken_label_ref = update_hash_for(LabelView, @parent1.label)
+    assert_raises(ViewModel::DeserializationError::ParentNotFound) do
+      ParentView.deserialize_from_view(
+        [{ '_type' => 'Parent',
+           'name'  => 'newp',
+           'label' => taken_label_ref }])
+    end
+  end
+
+  class GCTests < ActiveSupport::TestCase
+    include ARVMTestUtilities
+    include WithLabel
+    include WithOwner
+    include WithParent
+
+    # test belongs_to garbage collection - dependent: delete_all
+    def test_gc_dependent_delete_all
+      owner = Owner.create(deleted: Label.new(text: 'one'))
+      old_label = owner.deleted
+
+      alter_by_view!(OwnerView, owner) do |ov, refs|
+        ov['deleted'] = { '_type' => 'Label', 'text' => 'two' }
+      end
+
+      assert_equal('two', owner.deleted.text)
+      refute_equal(old_label, owner.deleted)
+      assert(Label.where(id: old_label.id).blank?)
+    end
+
+    def test_no_gc_dependent_ignore
+      owner = Owner.create(ignored: Label.new(text: "one"))
+      old_label = owner.ignored
+
+      alter_by_view!(OwnerView, owner) do |ov, refs|
+        ov['ignored'] = { '_type' => 'Label', 'text' => 'two' }
+      end
+      assert_equal('two', owner.ignored.text)
+      refute_equal(old_label, owner.ignored)
+      assert_equal(1, Label.where(id: old_label.id).count)
+    end
+  end
+
+  class RenamedTest < ActiveSupport::TestCase
+    include ARVMTestUtilities
+    include WithLabel
+
+    def before_all
+      super
+
+      build_viewmodel(:Parent) do
+        define_schema do |t|
+          t.string :name
+          t.references :label, foreign_key: true
+        end
+
+        define_model do
+          belongs_to :label, inverse_of: :parent, dependent: :destroy
+        end
+
+        define_viewmodel do
+          attributes :name
+          association :label, as: :something_else
+        end
+      end
+    end
+
+    def setup
+      super
+
+      @parent = Parent.create(name: 'p1', label: Label.new(text: 'l1'))
+
+      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('label' => DeepPreloader::Spec.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.label.id,
+                       '_type'    => 'Label',
+                       '_version' => 1,
+                       'text'     => 'l1' },
+                     view['something_else'])
+        view['something_else']['text'] = 'new l1 text'
+      end
+      assert_equal('new l1 text', @parent.label.text)
+    end
+  end
+
+  class FreedChildrenTest < ActiveSupport::TestCase
+    include ARVMTestUtilities
+
+    def before_all
+      build_viewmodel(:Aye) do
+        define_schema do |t|
+          t.references :bee
+        end
+        define_model do
+          belongs_to :bee, inverse_of: :aye, dependent: :destroy
+        end
+        define_viewmodel do
+          association :bee
+        end
+      end
+
+      build_viewmodel(:Bee) do
+        define_schema do |t|
+          t.references :cee
+        end
+        define_model do
+          has_one :aye, inverse_of: :bee
+          belongs_to :cee, inverse_of: :bee, dependent: :destroy
+        end
+        define_viewmodel do
+          association :cee
+        end
+      end
+
+      build_viewmodel(:Cee) do
+        define_schema do |t|
+        end
+        define_model do
+          has_one :bee, inverse_of: :cee
+        end
+        define_viewmodel do
+        end
+      end
+    end
+
+
+    # Do we support replacing a node in the tree and reparenting its children
+    # back to it? In theory we want to, but currently we don't: the child node
+    # is unresolvable.
+
+    # To support it we could maintain a list of child elements that will be
+    # implicitly freed by each freelist entry. Then worklist entries could
+    # resolve themselves from these children, and nil out the association target
+    # in the freelist to prevent them from being deleted when the freelist is
+    # cleaned. If the freelist entry is subsequently reclaimed, double update
+    # protection should prevent the child from being reused, but that will need
+    # testing.
+    def test_move
+      model = Aye.create(bee: Bee.new(cee: Cee.new))
+      assert_raises(ViewModel::DeserializationError::ParentNotFound) do
+        alter_by_view!(AyeView, model) do |view, refs|
+          view['bee'].delete("id")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "minitest/unit"
+require "minitest/hooks"
+
+require_relative "../../../helpers/arvm_test_models.rb"
+require_relative "../../../helpers/arvm_test_utilities.rb"
+require_relative "../../../helpers/viewmodel_spec_helpers.rb"
+
+require "view_model"
+require "view_model/active_record"
+
+# IknowCache uses Rails.cache: create a dummy cache.
+
+DUMMY_RAILS_CACHE = ActiveSupport::Cache::MemoryStore.new
+
+module Rails
+  def self.cache
+    DUMMY_RAILS_CACHE
+  end
+end
+
+class ViewModel::ActiveRecord
+  class CacheTest < ActiveSupport::TestCase
+    using ViewModel::Utils::Collections
+    extend Minitest::Spec::DSL
+    include ARVMTestUtilities
+
+    # Defines a cacheable parent Model with a owned Child and a cachable shared Shared.
+    module CacheableParentAndChildren
+      extend ActiveSupport::Concern
+      include ViewModelSpecHelpers::ParentAndBelongsToChild
+
+      def model_attributes
+        super.merge(
+          schema:    ->(t) { t.references :shared, foreign_key: true },
+          model:     ->(_) { belongs_to :shared, inverse_of: :models },
+          viewmodel: ->(_) {
+            association :shared, shared: true, optional: false
+            cacheable!
+          }
+        )
+      end
+
+      def shared_cache_group
+        @shared_cache_group ||= IknowCache.register_group(:shared, :id)
+      end
+
+      def shared_viewmodel_class
+        shared_cache_group = self.shared_cache_group
+        @shared_viewmodel_class ||= define_viewmodel_class(:Shared, namespace: namespace) do
+          define_schema do |t|
+            t.string :name
+          end
+
+          define_model do
+            has_many :models
+          end
+
+          define_viewmodel do
+            attributes :name
+            cacheable!(cache_group: shared_cache_group)
+          end
+        end
+      end
+
+      def shared_model_class
+        shared_viewmodel_class.model_class
+      end
+
+      # parent depends on children, ensure it's touched first
+      def viewmodel_class
+        shared_viewmodel_class
+        super
+      end
+
+      included do
+        let(:shared)     { shared_model_class.create!(name: "shared1") }
+        let(:root)       { model_class.create!(name: "root1", child: Child.new(name: "owned1"), shared: shared) }
+        let(:root_view)  { viewmodel_class.new(root) }
+      end
+    end
+
+    before(:each) do
+      DUMMY_RAILS_CACHE.clear
+    end
+
+    # Extract the iKnowCaches to verify their contents
+    def read_cache(viewmodel_class, id)
+      vm_cache = viewmodel_class.viewmodel_cache
+      vm_cache.send(:cache).read(vm_cache.key_for(id))
+    end
+
+    def serialize_from_database
+      view    = viewmodel_class.new(model_class.find(root.id))
+      context = viewmodel_class.new_serialize_context
+      data    = ViewModel.serialize_to_hash([view], serialize_context: context)
+      refs    = context.serialize_references_to_hash
+      [data, refs]
+    end
+
+    def parse_result(result)
+      data_json, refs_json = result
+      data                 = data_json.map { |d| JSON.parse(d) }
+      refs                 = refs_json.transform_values { |v| JSON.parse(v) }
+      [data, refs]
+    end
+
+    def fetch_with_cache
+      viewmodel_class.viewmodel_cache.fetch([root.id])
+    end
+
+    def serialize_with_cache
+      parse_result(fetch_with_cache)
+    end
+
+    module BehavesLikeACache
+      extend ActiveSupport::Concern
+      included do
+        it 'returns the right serialization' do
+          value(serialize_with_cache).must_equal(serialize_from_database)
+        end
+
+        it 'returns the right serialization after caching' do
+          fetch_with_cache
+          value(serialize_from_database).must_equal(serialize_with_cache)
+        end
+
+        it 'writes to the cache after fetching' do
+          cached_value = read_cache(viewmodel_class, root.id)
+          value(cached_value).wont_be(:present?)
+
+          fetch_with_cache
+
+          cached_value = read_cache(viewmodel_class, root.id)
+          value(cached_value).must_be(:present?)
+        end
+
+        it 'saves the returned serialization in the cache' do
+          data, refs = fetch_with_cache
+          value(data.size).must_equal(1)
+
+          cached_root = read_cache(viewmodel_class, root.id)
+          value(cached_root).must_be(:present?)
+          value(cached_root[:data]).must_equal(data.first)
+
+          ref_cache = cached_root[:ref_cache]
+          value(refs.size).must_equal(ref_cache.size)
+
+          refs.each do |key, ref_data|
+            view_name, id = ref_cache[key]
+            value(view_name).must_be(:present?)
+            value(id).must_be(:present?)
+
+            # The cached reference must correspond to the returned data.
+            parsed_data = JSON.parse(ref_data)
+            value(parsed_data["id"]).must_equal(id)
+            value(parsed_data["_type"]).must_equal(view_name)
+
+            # When the cached reference is to independently cached data
+            # (SharedView in this test), make sure that data is correctly
+            # cached.
+            next unless view_name == "Shared"
+            value(id).must_equal(shared.id)
+            cached_shared = read_cache(shared_viewmodel_class, id)
+            value(cached_shared).must_be(:present?)
+            value(cached_shared[:data]).must_equal(ref_data)
+            value(cached_shared[:ref_cache]).must_be(:blank?)
+          end
+        end
+      end
+    end
+
+    describe 'with owned and shared children' do
+      include CacheableParentAndChildren
+      include BehavesLikeACache
+
+      describe 'with a record in the cache' do
+        # Fetch the root record to ensure it's in the cache
+        before(:each) do
+          viewmodel_class.viewmodel_cache.fetch([root.id])
+        end
+
+        def change_in_database
+          root.update_attribute(:name, "CHANGEDROOT")
+          shared.update_attribute(:name, "CHANGEDSHARED")
+        end
+
+        it 'resolves from the cache' do
+          before_data, before_refs = serialize_from_database
+          change_in_database
+
+          cache_data, cache_refs = serialize_with_cache
+          value(cache_data).must_equal(before_data)
+          value(cache_refs).must_equal(before_refs)
+        end
+
+        it 'can clear the root cache' do
+          _before_data, before_refs = serialize_from_database
+          change_in_database
+          viewmodel_class.viewmodel_cache.clear
+
+          cache_data, cache_refs = serialize_with_cache
+          value(cache_data[0]["name"]).must_equal("CHANGEDROOT") # Root view invalidated
+          value(cache_refs).must_equal(before_refs) # Shared view not invalidated
+        end
+
+        describe 'when deserializing' do
+          it 'does not clear the cache on round-trip' do
+            alter_by_view!(viewmodel_class, root) {}
+
+            cached_root_value = read_cache(viewmodel_class, root.id)
+            value(cached_root_value).must_be(:present?)
+
+            cached_root_value = read_cache(shared_viewmodel_class, shared.id)
+            value(cached_root_value).must_be(:present?)
+          end
+
+          it 'clears only the root cache on edit to root' do
+            alter_by_view!(viewmodel_class, root) do |data, _refs|
+              data['name'] = 'new name'
+            end
+
+            cached_root_value = read_cache(viewmodel_class, root.id)
+            value(cached_root_value).wont_be(:present?)
+
+            cached_root_value = read_cache(shared_viewmodel_class, shared.id)
+            value(cached_root_value).must_be(:present?)
+          end
+
+          it 'clears only the root cache on edit to owned child' do
+            alter_by_view!(viewmodel_class, root) do |data, _refs|
+              data['child']['name'] = 'new child name'
+            end
+
+            cached_root_value = read_cache(viewmodel_class, root.id)
+            value(cached_root_value).wont_be(:present?)
+
+            cached_root_value = read_cache(shared_viewmodel_class, shared.id)
+            value(cached_root_value).must_be(:present?)
+          end
+
+          it 'clears only the shared child cache on edit to shared child' do
+            alter_by_view!(viewmodel_class, root) do |_data, refs|
+              refs.values.first['name'] = 'new shared name'
+            end
+
+            cached_root_value = read_cache(viewmodel_class, root.id)
+            value(cached_root_value).must_be(:present?)
+
+            cached_root_value = read_cache(shared_viewmodel_class, shared.id)
+            value(cached_root_value).wont_be(:present?)
+          end
+        end
+
+        it 'can delete an entity from a cache' do
+          _before_data, before_refs = serialize_from_database
+          change_in_database
+          viewmodel_class.viewmodel_cache.delete(root.id)
+
+          cache_data, cache_refs = serialize_with_cache
+          value(cache_data[0]["name"]).must_equal("CHANGEDROOT")
+          value(cache_refs).must_equal(before_refs)
+        end
+
+        it 'can clear a referenced cache' do
+          change_in_database
+          shared_viewmodel_class.viewmodel_cache.clear
+
+          # Shared view invalidated, but root view not
+          cache_data, cache_hrefs = serialize_with_cache
+          value(cache_data[0]["name"]).must_equal("root1")
+          value(cache_hrefs.values[0]["name"]).must_equal("CHANGEDSHARED")
+        end
+
+        it 'can clear a cache via its external cache group' do
+          change_in_database
+          shared_cache_group.invalidate_cache_group
+
+          # Shared view invalidated, but root view not
+          cache_data, cache_hrefs = serialize_with_cache
+          value(cache_data[0]["name"]).must_equal("root1")
+          value(cache_hrefs.values[0]["name"]).must_equal("CHANGEDSHARED")
+        end
+
+        describe 'and a record not in the cache' do
+          let(:root2) { model_class.create!(name: "root2", child: Child.new(name: "owned2"), shared: shared) }
+
+          def serialize_from_database
+            views   = model_class.find(root.id, root2.id).map { |r| viewmodel_class.new(r) }
+            context = viewmodel_class.new_serialize_context
+            data    = ViewModel.serialize_to_hash(views, serialize_context: context)
+            refs    = context.serialize_references_to_hash
+            [data, refs]
+          end
+
+          def fetch_with_cache
+            viewmodel_class.viewmodel_cache.fetch([root.id, root2.id])
+          end
+
+          it 'merges matching shared references between cache hits and misses' do
+            db_data, db_refs = serialize_from_database
+            value(db_refs.size).must_equal(1)
+
+            cache_data, cache_refs = serialize_with_cache
+            value(cache_data).must_equal(db_data)
+            value(cache_refs).must_equal(db_refs)
+          end
+
+          it 'merges cache hits and misses' do
+            _, refs = serialize_from_database
+            change_in_database
+
+            cache_data, cache_refs = serialize_with_cache
+            value(cache_data[0]["name"]).must_equal("root1")
+            value(cache_data[1]["name"]).must_equal("root2")
+            value(cache_refs).must_equal(refs)
+          end
+        end
+      end
+    end
+
+    describe "with a non-cacheable shared child" do
+      include ViewModelSpecHelpers::ParentAndSharedChild
+      def model_attributes
+        super.merge(viewmodel: ->(_) { cacheable! })
+      end
+
+      let(:root)       { model_class.create!(name: "root1", child: Child.new(name: "owned1")) }
+      let(:root_view)  { viewmodel_class.new(root) }
+
+      include BehavesLikeACache
+    end
+
+    describe 'when fetched by viewmodel' do
+      def fetch_with_cache
+        viewmodel_class.viewmodel_cache.fetch_by_viewmodel([root_view])
+      end
+
+      include CacheableParentAndChildren
+      include BehavesLikeACache
+
+      it 'can handle duplicates' do
+        data, _refs = viewmodel_class.viewmodel_cache.fetch_by_viewmodel([root_view, root_view])
+        value(data.size).must_equal(2)
+        value(data[0]).must_equal(data[1])
+      end
+    end
+  end
+end