iknow_view_models 2.8.4

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

@@ -0,0 +1,334 @@
+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::HasOneTest < ActiveSupport::TestCase
+  include ARVMTestUtilities
+
+  def self.build_target(arvm_test_case)
+    arvm_test_case.build_viewmodel(:Target) do
+      define_schema do |t|
+        t.string :text
+        t.references :parent, foreign_key: true
+      end
+
+      define_model do
+        belongs_to :parent, inverse_of: :target
+      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
+      end
+
+      define_model do
+        has_one    :target, dependent: :destroy, inverse_of: :parent
+      end
+
+      define_viewmodel do
+        attributes   :name
+        associations :target
+      end
+    end
+  end
+
+  def before_all
+    super
+
+    self.class.build_parent(self)
+    self.class.build_target(self)
+  end
+
+  def setup
+    super
+
+    # TODO make a `has_list?` that allows a parent to set all children as an array
+    @parent1 = Parent.new(name: "p1",
+                          target: Target.new(text: "p1t"))
+    @parent1.save!
+
+    @parent2 = Parent.new(name: "p2",
+                          target: Target.new(text: "p2t"))
+
+    @parent2.save!
+
+    enable_logging!
+  end
+
+  def test_loading_batching
+    log_queries do
+      serialize(ParentView.load)
+    end
+    assert_equal(['Parent Load', 'Target Load'],
+                 logged_load_queries)
+  end
+
+  def test_create_from_view
+    view = {
+      "_type"    => "Parent",
+      "name"     => "p",
+      "target"   => { "_type" => "Target", "text" => "t" },
+    }
+
+    pv = ParentView.deserialize_from_view(view)
+    p = pv.model
+
+    assert(!p.changed?)
+    assert(!p.new_record?)
+
+    assert_equal("p", p.name)
+
+
+    assert(p.target.present?)
+    assert_equal("t", p.target.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,
+                   "target"   => { "_type"    => "Target",
+                                   "_version" => 1,
+                                   "id"       => @parent1.target.id,
+                                   "text"     => @parent1.target.text } },
+                 view)
+  end
+
+  def test_swap_has_one
+    @parent1.update(target: t1 = Target.new)
+    @parent2.update(target: t2 = Target.new)
+
+    deserialize_context = ViewModelBase.new_deserialize_context
+
+    ParentView.deserialize_from_view(
+      [update_hash_for(ParentView, @parent1) { |p| p['target'] = update_hash_for(TargetView, t2) },
+       update_hash_for(ParentView, @parent2) { |p| p['target'] = update_hash_for(TargetView, t1) }],
+      deserialize_context: deserialize_context)
+
+    assert_equal(Set.new([ViewModel::Reference.new(ParentView, @parent1.id),
+                          ViewModel::Reference.new(ParentView, @parent2.id)]),
+                 deserialize_context.valid_edit_refs.to_set)
+
+    @parent1.reload
+    @parent2.reload
+
+    assert_equal(@parent1.target, t2)
+    assert_equal(@parent2.target, t1)
+  end
+
+  def test_has_one_create_nil
+    view = { '_type' => 'Parent', 'name' => 'p', 'target' => nil }
+    pv = ParentView.deserialize_from_view(view)
+    assert_nil(pv.model.target)
+  end
+
+  def test_has_one_create
+    @parent1.update(target: nil)
+
+    alter_by_view!(ParentView, @parent1) do |view, refs|
+      view['target'] = { '_type' => 'Target', 'text' => 't' }
+    end
+
+    assert_equal('t', @parent1.target.text)
+  end
+
+  def test_has_one_update
+    alter_by_view!(ParentView, @parent1) do |view, refs|
+      view['target']['text'] = "hello"
+    end
+
+    assert_equal('hello', @parent1.target.text)
+  end
+
+  def test_has_one_destroy
+    old_target = @parent1.target
+    alter_by_view!(ParentView, @parent1) do |view, refs|
+      view['target'] = nil
+    end
+    assert(Target.where(id: old_target.id).blank?)
+  end
+
+  def test_has_one_move_and_replace
+    old_parent1_target = @parent1.target
+    old_parent2_target = @parent2.target
+
+    alter_by_view!(ParentView, [@parent1, @parent2]) do |(p1, p2), refs|
+      p2['target'] = p1['target']
+      p1['target'] = nil
+    end
+
+    assert(@parent1.target.blank?)
+    assert_equal(old_parent1_target, @parent2.target)
+    assert(Target.where(id: old_parent2_target).blank?)
+  end
+
+  def test_has_one_cannot_duplicate_unreleased_child
+    # p2 shouldn't be able to copy p1's target
+    assert_raises(ViewModel::DeserializationError::DuplicateNodes) do
+      alter_by_view!(ParentView, [@parent1, @parent2]) do |(p1, p2), _refs|
+        p2['target'] = p1['target'].dup
+      end
+    end
+  end
+
+  def test_has_one_cannot_duplicate_implicitly_unreleased_child
+    # p2 shouldn't be able to copy p1's target, even when p1 doesn't explicitly
+    # specify the association
+    assert_raises(ViewModel::DeserializationError::ParentNotFound) do
+      alter_by_view!(ParentView, [@parent1, @parent2]) do |(p1, p2), _refs|
+        p2['target'] = p1['target']
+        p1.delete('target')
+      end
+    end
+  end
+
+  def test_has_one_cannot_take_from_outside_tree
+    t3 = Parent.create(target: Target.new(text: 'hi')).target
+
+    assert_raises(ViewModel::DeserializationError::ParentNotFound) do
+      alter_by_view!(ParentView, [@parent1]) do |(p1), _refs|
+        p1['target'] = update_hash_for(TargetView, t3)
+      end
+    end
+  end
+
+  def test_has_one_cannot_take_unparented_from_outside_tree
+    t3 = Target.create(text: 'hi') # no parent
+
+    assert_raises(ViewModel::DeserializationError::ParentNotFound) do
+      alter_by_view!(ParentView, @parent1) do |p1, _refs|
+        p1['target'] = update_hash_for(TargetView, t3)
+      end
+    end
+  end
+
+  def test_bad_single_association
+    view = {
+      "_type" => "Parent",
+      "target" => []
+    }
+    ex = assert_raises(ViewModel::DeserializationError::InvalidSyntax) do
+      ParentView.deserialize_from_view(view)
+    end
+    assert_match(/not an object/, ex.message)
+  end
+
+
+  class RenameTest < ActiveSupport::TestCase
+    include ARVMTestUtilities
+
+    def before_all
+      super
+
+      build_viewmodel(:Parent) do
+        define_schema do |t|
+          t.string :name
+        end
+
+        define_model do
+          has_one    :target, dependent: :destroy, inverse_of: :parent
+        end
+
+        define_viewmodel do
+          attributes   :name
+          association :target, as: :something_else
+        end
+      end
+
+      ViewModel::ActiveRecord::HasOneTest.build_target(self)
+    end
+
+    def setup
+      super
+
+      @parent = Parent.create(target: Target.new(text: 'target text'))
+
+      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('target' => 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.target.id,
+                       '_type'    => 'Target',
+                       '_version' => 1,
+                       'text'     => 'target text' },
+                     view['something_else'])
+        view['something_else']['text'] = 'target new text'
+      end
+
+      assert_equal('target new text',  @parent.target.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|
+        end
+        define_model do
+          has_one :aye, inverse_of: :bee
+          has_one :cee, inverse_of: :bee, dependent: :destroy
+        end
+        define_viewmodel do
+          association :cee
+        end
+      end
+
+      build_viewmodel(:Cee) do
+        define_schema do |t|
+          t.references :bee
+        end
+        define_model do
+          belongs_to :bee, inverse_of: :cee
+        end
+        define_viewmodel do
+        end
+      end
+    end
+
+    def test_reclaim_grandchild_from_deleted_child
+      skip 'Issue #8'
+
+      model = Aye.create(bee: Bee.new(cee: Cee.new))
+
+      # This test currently fails because we only release the top of the deleted
+      # subtree to the release pool, and so its children cannot be reclaimed.
+      alter_by_view!(AyeView, model) do |view, _refs|
+        view['bee'].delete('id')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require "minitest/autorun"
+require "minitest/unit"
+require "minitest/hooks"
+
+require_relative "../../../helpers/arvm_test_utilities.rb"
+require_relative "../../../helpers/arvm_test_models.rb"
+require_relative "../../../helpers/viewmodel_spec_helpers.rb"
+
+require "view_model"
+require "view_model/active_record"
+
+module NSTest
+end
+
+class ViewModel::ActiveRecord::NamespacingTest < ActiveSupport::TestCase
+  include ViewModelSpecHelpers::ParentAndHasOneChild
+  extend Minitest::Spec::DSL
+
+  def namespace
+    NSTest
+  end
+
+  def model_attributes
+    parent_attrs = super
+
+    ViewModel::TestHelpers::ARVMBuilder::Spec.new(
+      schema:    parent_attrs.schema,
+      viewmodel: parent_attrs.viewmodel,
+      model:     ->(_) {
+        has_one :child, inverse_of: :model, class_name: "NSTest::Child", dependent: :destroy
+      })
+  end
+
+  describe 'inference' do
+    it "assigns a transformed view name from a namespaced class" do
+      assert_equal("NSTest.Model", viewmodel_class.view_name)
+    end
+
+    it "can look up a viewmodel by inference from an association to a namespaced model" do
+      child_viewmodel_class # test depends on child_viewmodel_class
+
+      assert_equal(viewmodel_class._association_data('child').viewmodel_class,
+                   child_viewmodel_class)
+    end
+
+    it "can infer the model class from a namespaced view class name" do
+      assert_equal(viewmodel_class.model_class, model_class)
+    end
+  end
+
+  describe 'access control' do
+    include ARVMTestUtilities
+
+    it 'can apply access control policy for namespaced classes' do
+      _viewmodel_class = viewmodel_class
+
+      access_control_class =
+        Class.new(ViewModel::AccessControl::Tree) do
+          view(_viewmodel_class.view_name) do
+            visible_unless!("VETO-ERROR-MESSAGE") { true }
+          end
+        end
+
+      child_viewmodel_class # test depends on child_viewmodel_class
+
+      serialize_context = viewmodel_class.new_serialize_context(
+        access_control: access_control_class.new)
+
+      refute_serializes(viewmodel_class,
+                        model_class.create!,
+                        "VETO-ERROR-MESSAGE",
+                        serialize_context: serialize_context)
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+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::AttributeViewTest < ActiveSupport::TestCase
+  include ARVMTestUtilities
+
+  def before_all
+    super
+
+    build_viewmodel(:Thing) do
+      define_schema do |t|
+        t.integer :a
+        t.integer :b
+      end
+
+      define_model do
+      end
+
+      define_viewmodel do
+        attribute :a
+        attribute :b, optional: true
+      end
+    end
+  end
+
+  def setup
+    super
+    @thing = Thing.create!(a: 1, b: 2)
+
+    @skel = { "_type"    => "Thing",
+              "_version" => 1,
+              "id"       => @thing.id }
+  end
+
+  def test_optional_not_serialized
+    view, _refs = serialize_with_references(ThingView.new(@thing))
+
+    assert_equal(@skel.merge("a" => 1), view)
+  end
+
+  def test_optional_included
+    view, _refs = serialize_with_references(ThingView.new(@thing),
+                                            serialize_context: ThingView.new_serialize_context(include: :b))
+
+    assert_equal(@skel.merge("a" => 1, "b" => 2), view)
+  end
+
+  def test_pruned_not_included
+    view, _refs = serialize_with_references(ThingView.new(@thing),
+                                            serialize_context: ThingView.new_serialize_context(include: :b, prune: :a))
+
+    assert_equal(@skel.merge("b" => 2), view)
+  end
+end