iknow_view_models 3.1.5 → 3.2.1

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative '../../../helpers/arvm_test_utilities'
+require_relative '../../../helpers/arvm_test_models'
+require_relative '../../../helpers/viewmodel_spec_helpers'
+
+require 'minitest/autorun'
+
+require 'view_model/active_record'
+
+class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
+  include ARVMTestUtilities
+  extend Minitest::Spec::DSL
+
+  include ViewModelSpecHelpers::ParentAndBelongsToChildWithMigration
+
+  def new_model
+    model_class.new(name: 'm1', child: child_model_class.new(name: 'c1'))
+  end
+
+  let(:viewmodel) { create_viewmodel! }
+
+  let(:current_serialization) { ViewModel.serialize_to_hash(viewmodel) }
+
+  let(:v2_serialization) do
+    {
+      ViewModel::TYPE_ATTRIBUTE => viewmodel_class.view_name,
+      ViewModel::VERSION_ATTRIBUTE => 2,
+      ViewModel::ID_ATTRIBUTE => viewmodel.id,
+      'name' => viewmodel.name,
+      'old_field' => 1,
+      'child' => {
+        ViewModel::TYPE_ATTRIBUTE => child_viewmodel_class.view_name,
+        ViewModel::VERSION_ATTRIBUTE => 2,
+        ViewModel::ID_ATTRIBUTE => viewmodel.child.id,
+        'name' => viewmodel.child.name,
+        'former_field' => 'former_value',
+      },
+    }
+  end
+
+  let(:migration_versions) { { viewmodel_class => 2, child_viewmodel_class => 2 } }
+
+  let(:down_migrator) { ViewModel::DownMigrator.new(migration_versions) }
+  let(:up_migrator) { ViewModel::UpMigrator.new(migration_versions) }
+
+  def migrate!
+    migrator.migrate!(subject, references: {})
+  end
+
+  describe 'downwards' do
+    let(:migrator) { down_migrator }
+    let(:subject) { current_serialization.deep_dup }
+
+    let(:expected_result) do
+      v2_serialization.deep_merge(
+        {
+          ViewModel::MIGRATED_ATTRIBUTE => true,
+          'old_field' => -1,
+          'child' => {
+            ViewModel::MIGRATED_ATTRIBUTE => true,
+            'former_field' => 'reconstructed',
+          },
+        },
+      )
+    end
+
+    it 'migrates' do
+      migrate!
+
+      assert_equal(expected_result, subject)
+    end
+
+    describe 'to an unreachable version' do
+      let(:migration_versions) { { viewmodel_class => 2, child_viewmodel_class => 1 } }
+
+      it 'raises' do
+        assert_raises(ViewModel::Migration::NoPathError) do
+          migrate!
+        end
+      end
+    end
+  end
+
+  describe 'upwards' do
+    let(:migrator) { up_migrator }
+    let(:subject) { v2_serialization.deep_dup }
+
+    let(:expected_result) do
+      current_serialization.deep_merge(
+        ViewModel::MIGRATED_ATTRIBUTE => true,
+        'new_field' => 3,
+        'child' => {
+          ViewModel::MIGRATED_ATTRIBUTE => true,
+        },
+      )
+    end
+
+    it 'migrates' do
+      migrate!
+
+      assert_equal(expected_result, subject)
+    end
+
+    describe 'with version unspecified' do
+      let(:subject) do
+        v2_serialization
+          .except(ViewModel::VERSION_ATTRIBUTE)
+      end
+
+      it 'treats it as the requested version' do
+        migrate!
+        assert_equal(expected_result, subject)
+      end
+    end
+
+    describe 'with a version not in the specification' do
+      let(:subject) do
+        v2_serialization
+          .except('old_field')
+          .deep_merge(ViewModel::VERSION_ATTRIBUTE => 3, 'mid_field' => 1)
+      end
+
+      it 'rejects it' do
+        assert_raises(ViewModel::Migration::UnspecifiedVersionError) do
+          migrate!
+        end
+      end
+    end
+
+    describe 'from an unreachable version' do
+      let(:migration_versions) { { viewmodel_class => 2, child_viewmodel_class => 1 } }
+
+      let(:subject) do
+        v2_serialization.deep_merge(
+          'child' => { ViewModel::VERSION_ATTRIBUTE => 1 },
+        )
+      end
+
+      it 'raises' do
+        assert_raises(ViewModel::Migration::NoPathError) do
+          migrate!
+        end
+      end
+    end
+
+    describe 'in an undefined direction' do
+      let(:migration_versions) { { viewmodel_class => 1, child_viewmodel_class => 2 } }
+
+      let(:subject) do
+        v2_serialization.except('old_field').merge(ViewModel::VERSION_ATTRIBUTE => 1)
+      end
+
+      it 'raises' do
+        assert_raises(ViewModel::Migration::OneWayError) do
+          migrate!
+        end
+      end
+    end
+  end
+end

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

@@ -1,13 +1,15 @@
-require "minitest/autorun"
-require "minitest/unit"
-require "minitest/hooks"
+# frozen_string_literal: true
 
-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 'minitest/unit'
+require 'minitest/hooks'
 
-require "view_model"
-require "view_model/active_record"
+require_relative '../../../helpers/arvm_test_utilities'
+require_relative '../../../helpers/arvm_test_models'
+require_relative '../../../helpers/viewmodel_spec_helpers'
+
+require 'view_model'
+require 'view_model/active_record'
 
 module NSTest
 end
@@ -27,23 +29,23 @@ class ViewModel::ActiveRecord::NamespacingTest < ActiveSupport::TestCase
       schema:    parent_attrs.schema,
       viewmodel: parent_attrs.viewmodel,
       model:     ->(_) {
-        has_one :child, inverse_of: :model, class_name: "NSTest::Child", dependent: :destroy
+        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)
+    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
+    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
+    it 'can infer the model class from a namespaced view class name' do
       assert_equal(viewmodel_class.model_class, model_class)
     end
   end
@@ -52,12 +54,12 @@ class ViewModel::ActiveRecord::NamespacingTest < ActiveSupport::TestCase
     include ARVMTestUtilities
 
     it 'can apply access control policy for namespaced classes' do
-      _viewmodel_class = viewmodel_class
+      p_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 }
+          view(p_viewmodel_class.view_name) do
+            visible_unless!('VETO-ERROR-MESSAGE') { true }
           end
         end
 
@@ -68,7 +70,7 @@ class ViewModel::ActiveRecord::NamespacingTest < ActiveSupport::TestCase
 
       refute_serializes(viewmodel_class,
                         model_class.create!,
-                        "VETO-ERROR-MESSAGE",
+                        'VETO-ERROR-MESSAGE',
                         serialize_context: serialize_context)
     end
   end

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

@@ -1,9 +1,11 @@
-require_relative "../../../helpers/arvm_test_utilities.rb"
-require_relative "../../../helpers/arvm_test_models.rb"
+# frozen_string_literal: true
 
-require "minitest/autorun"
+require_relative '../../../helpers/arvm_test_utilities'
+require_relative '../../../helpers/arvm_test_models'
 
-require "view_model/active_record"
+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)
@@ -70,17 +72,17 @@ module ViewModel::ActiveRecord::PolyTest
 
     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")])
+      @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" }
+        '_type' => 'PolyParentOne',
+        'text'  => 'p',
+        'child' => { '_type' => 'Child', 'text' => 'c' },
       }
       p1v = PolyParentOneView.deserialize_from_view(p1_view)
       p1 = p1v.model
@@ -92,9 +94,9 @@ module ViewModel::ActiveRecord::PolyTest
 
     def test_create_has_many_from_view
       p2_view = {
-        "_type" => "PolyParentTwo",
-        "num"   => "2",
-        "children" => [{ "_type" => "Child", "text" => "c1" }, { "_type" => "Child", "text" => "c2" }]
+        '_type' => 'PolyParentTwo',
+        'num'   => '2',
+        'children' => [{ '_type' => 'Child', 'text' => 'c1' }, { '_type' => 'Child', 'text' => 'c2' }],
       }
       p2v = PolyParentTwoView.deserialize_from_view(p2_view)
       p2 = p2v.model
@@ -108,15 +110,15 @@ module ViewModel::ActiveRecord::PolyTest
 
     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)
+      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)
+      assert_equal('c3', @grandparent.poly_parent_one.child.text)
+      assert_equal(['c1', 'c2'], @grandparent.poly_parent_two.children.map(&:text).sort)
     end
   end
 
@@ -166,13 +168,12 @@ module ViewModel::ActiveRecord::PolyTest
         end
 
         define_viewmodel do
-          attributes   :name
+          attributes :name
           association :poly, viewmodels: [PolyOneView, PolyTwoView]
         end
       end
     end
 
-
     def before_all
       super
       self.class.build_poly_children(self)
@@ -182,17 +183,17 @@ module ViewModel::ActiveRecord::PolyTest
     def setup
       super
 
-      @parent1 = Parent.create(name: "p1",
+      @parent1 = Parent.create(name: 'p1',
                                poly: PolyOne.new(number: 1))
 
-      @parent2 = Parent.create(name: "p2")
+      @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)
+      Parent.create(name: 'with PolyOne', poly: PolyOne.new)
+      Parent.create(name: 'with PolyTwo', poly: PolyTwo.new)
 
       log_queries do
         serialize(ParentView.load)
@@ -203,9 +204,9 @@ module ViewModel::ActiveRecord::PolyTest
 
     def test_create_from_view
       view = {
-        "_type"    => "Parent",
-        "name"     => "p",
-        "poly"     => { "_type" => "PolyTwo", "text" => "pol" }
+        '_type'    => 'Parent',
+        'name'     => 'p',
+        'poly'     => { '_type' => 'PolyTwo', 'text' => 'pol' },
       }
 
       pv = ParentView.deserialize_from_view(view)
@@ -214,25 +215,24 @@ module ViewModel::ActiveRecord::PolyTest
       assert(!p.changed?)
       assert(!p.new_record?)
 
-      assert_equal("p", p.name)
+      assert_equal('p', p.name)
 
       assert(p.poly.present?)
       assert(p.poly.is_a?(PolyTwo))
-      assert_equal("pol", p.poly.text)
+      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 }
+      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
@@ -247,14 +247,14 @@ module ViewModel::ActiveRecord::PolyTest
               '_type'    => 'SomethingThatsNotActuallyAType',
               '_version' => 1,
             } })
-        end
-        assert_match(/\binvalid\b.+\bviewmodel type\b/i, ex.message)
+      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|
+      alter_by_view!(ParentView, @parent1) do |view, _refs|
         view['poly'] = { '_type' => 'PolyTwo', 'text' => 'hi' }
       end
 
@@ -302,18 +302,17 @@ module ViewModel::ActiveRecord::PolyTest
       end
 
       def test_renamed_roundtrip
-        alter_by_view!(ParentView, @parent) do |view, refs|
+        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'}
+          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

@@ -1,9 +1,11 @@
-require_relative "../../../helpers/arvm_test_utilities.rb"
-require_relative "../../../helpers/arvm_test_models.rb"
+# frozen_string_literal: true
 
-require "minitest/autorun"
+require_relative '../../../helpers/arvm_test_utilities'
+require_relative '../../../helpers/arvm_test_models'
 
-require "view_model/active_record"
+require 'minitest/autorun'
+
+require 'view_model/active_record'
 
 class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
   include ARVMTestUtilities
@@ -58,12 +60,12 @@ class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
   def setup
     super
 
-    @parent1 = Parent.create(name: "p1",
-                             category: Category.new(name: "p1cat"))
+    @parent1 = Parent.create(name: 'p1',
+                             category: Category.new(name: 'p1cat'))
 
-    @parent2 = Parent.create(name: "p2")
+    @parent2 = Parent.create(name: 'p2')
 
-    @category1 = Category.create(name: "Cat1")
+    @category1 = Category.create(name: 'Cat1')
 
     enable_logging!
   end
@@ -72,7 +74,7 @@ class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
     Parent.create(category: Category.new)
 
     log_queries do
-      serialize(ParentView.load())
+      serialize(ParentView.load)
     end
     assert_equal(['Parent Load', 'Category Load'],
                  logged_load_queries)
@@ -80,12 +82,12 @@ class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
 
   def test_create_from_view
     view = {
-      "_type"    => "Parent",
-      "name"     => "p",
-      "category"   => { "_ref" => "r1" },
+      '_type'    => 'Parent',
+      'name'     => 'p',
+      'category' => { '_ref' => 'r1' },
     }
     refs = {
-      "r1" => { "_type" => "Category", "name" => "newcat"}
+      'r1' => { '_type' => 'Category', 'name' => 'newcat' },
     }
 
     pv = ParentView.deserialize_from_view(view, references: refs)
@@ -94,27 +96,27 @@ class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
     assert(!p.changed?)
     assert(!p.new_record?)
 
-    assert_equal("p", p.name)
+    assert_equal('p', p.name)
 
     assert(p.category.present?)
-    assert_equal("newcat", p.category.name)
+    assert_equal('newcat', p.category.name)
   end
 
   def test_serialize_view
     view, refs = serialize_with_references(ParentView.new(@parent1))
     cat1_ref = refs.detect { |_, v| v['_type'] == 'Category' }.first
 
-    assert_equal({cat1_ref => { '_type'    => "Category",
-                                "_version" => 1,
+    assert_equal({ cat1_ref => { '_type' => 'Category',
+                                '_version' => 1,
                                 'id'       => @parent1.category.id,
-                                'name'     => @parent1.category.name }},
+                                'name'     => @parent1.category.name } },
                  refs)
 
-    assert_equal({ "_type"    => "Parent",
-                   "_version" => 1,
-                   "id"       => @parent1.id,
-                   "name"     => @parent1.name,
-                   "category" => { "_ref" => cat1_ref } },
+    assert_equal({ '_type'    => 'Parent',
+                   '_version' => 1,
+                   'id'       => @parent1.id,
+                   'name'     => @parent1.name,
+                   'category' => { '_ref' => cat1_ref } },
                  view)
   end
 
@@ -126,7 +128,7 @@ class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
   def test_shared_serialize_interning
     @parent2.update(category: @parent1.category)
     view, refs = serialize_with_references([ParentView.new(@parent1),
-                                            ParentView.new(@parent2)])
+                                            ParentView.new(@parent2),])
 
     category_ref = view.first['category']['_ref']
 
@@ -158,7 +160,7 @@ class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
 
   def test_shared_requires_all_references
     ex = assert_raises(ViewModel::DeserializationError::InvalidStructure) do
-      alter_by_view!(ParentView, @parent2) do |p2view, refs|
+      alter_by_view!(ParentView, @parent2) do |_p2view, refs|
         refs['spurious_ref'] = { '_type' => 'Parent', 'id' => @parent1.id }
       end
     end
@@ -167,7 +169,7 @@ class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
 
   def test_shared_requires_valid_references
     assert_raises(ViewModel::DeserializationError::InvalidSharedReference) do
-      alter_by_view!(ParentView, @parent1) do |p1view, refs|
+      alter_by_view!(ParentView, @parent1) do |_p1view, refs|
         refs.clear # remove the expected serialized refs
       end
     end
@@ -180,7 +182,7 @@ class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
         refs['p2'] = update_hash_for(ParentView, @parent2)
       end
     end
-    assert_equal("category", ex.association)
+    assert_equal('category', ex.association)
   end
 
   def test_shared_requires_unique_references
@@ -217,7 +219,7 @@ class ViewModel::ActiveRecord::SharedTest < ActiveSupport::TestCase
     d_context = ParentView.new_deserialize_context
 
     alter_by_view!(ParentView, @parent1, deserialize_context: d_context) do |view, refs|
-      refs[view['category']["_ref"]]["name"] = "changed"
+      refs[view['category']['_ref']]['name'] = 'changed'
     end
 
     assert(d_context.valid_edit_refs.include?(ViewModel::Reference.new(CategoryView, @parent1.category.id)))