iknow_view_models 3.5.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cb094f674e990ef9a67bbcb7b0ee260065356cdb6a56ee6e1b19582c320e96c
-  data.tar.gz: 5bb5c175e7fd30442794c2ff87687eb5dec132fa7da0d0128a1b012bd50131d6
+  metadata.gz: 573266179096880a34febada583570484e420b91a242920198cfa119192c3fbc
+  data.tar.gz: c024eb9398a4b0d49103d1806379d0f20312f7c6965e9fe2751b09bb720f2fc3
 SHA512:
-  metadata.gz: f196d4af404bcb91d88519e04ed2afcd7d73c590af4838e16b32b4f73171d20500a4a092cb76d693d7a683bf4ca6ad337d5e79a10a5233870f9c244acfffe969
-  data.tar.gz: bfdd726357dc50f72732498d112274301089ab82719e46d7c5d7bfc5414a6bcf3dc12459bb9dee6ffa9c174dea1c81e2a0499649d9bbe1d1618702bfad18ef04
+  metadata.gz: 353f42c901c4d52cba6bbe459cc6266c2e59f3a56ca432bac616cd4534c95116d0a0e27b8329799717259640e098c704c4f6b63c83713cd42cb3096c6ca6c5b3
+  data.tar.gz: 4e74aa987e3ff26dd9b14bb3fbebc291ce86087dca8f8bcc93ef9b320d7d7ed22f150ce4f3153e27c51f6a2f8d6561fe53cdcb7ac45734caf156f50b10a543d1

data/lib/iknow_view_models/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IknowViewModels
-  VERSION = '3.5.0'
+  VERSION = '3.6.0'
 end

data/lib/view_model/migratable_view.rb

@@ -34,14 +34,36 @@ module ViewModel::MigratableView
       end
     end
 
+    protected
+
+    def migration_class(from, to)
+      @migration_classes.fetch([from, to]) do
+        raise ViewModel::Migration::NoPathError.new(self, from, to)
+      end
+    end
+
     private
 
     # Define a migration on this viewmodel
-    def migrates(from:, to:, &block)
+    def migrates(from:, to:, inherit: nil, at: nil, &block)
       @migrations_lock.synchronize do
-        builder = ViewModel::Migration::Builder.new
+        migration_superclass =
+          if inherit
+            raise ArgumentError.new('Must provide inherit version') unless at
+
+            inherit.migration_class(at - 1, at)
+          else
+            ViewModel::Migration
+          end
+
+        builder = ViewModel::Migration::Builder.new(migration_superclass)
         builder.instance_exec(&block)
-        @migration_classes[[from, to]] = builder.build!
+
+        migration_class = builder.build!
+
+        const_set(:"Migration_#{from}_To_#{to}", migration_class)
+        @migration_classes[[from, to]] = migration_class
+
         @realized_migration_paths = false
       end
     end

data/lib/view_model/migration.rb

@@ -15,13 +15,14 @@ class ViewModel::Migration
 
   # Tiny DSL for defining migration classes
   class Builder
-    def initialize
+    def initialize(superclass = ViewModel::Migration)
+      @superclass = superclass
       @up_block = nil
       @down_block = nil
     end
 
     def build!
-      migration = Class.new(ViewModel::Migration)
+      migration = Class.new(@superclass)
       migration.define_method(:up, &@up_block) if @up_block
       migration.define_method(:down, &@down_block) if @down_block
       migration

data/lib/view_model/migrator.rb

@@ -75,6 +75,32 @@ class ViewModel
   class UpMigrator < Migrator
     private
 
+    def migrate_tree!(node, references:)
+      if node.is_a?(Hash) && node[ViewModel::TYPE_ATTRIBUTE] == ViewModel::ActiveRecord::FUNCTIONAL_UPDATE_TYPE
+        migrate_functional_update!(node, references: references)
+      else
+        super
+      end
+    end
+
+    NESTED_FUPDATE_TYPES = ['append', 'update'].freeze
+
+    # The functional update structure uses `_type` internally with a
+    # context-dependent meaning. Retrospectively this was a poor choice, but we
+    # need to account for it here.
+    def migrate_functional_update!(node, references:)
+      actions = node[ViewModel::ActiveRecord::ACTIONS_ATTRIBUTE]
+      actions&.each do |action|
+        action_type = action[ViewModel::TYPE_ATTRIBUTE]
+        next unless NESTED_FUPDATE_TYPES.include?(action_type)
+
+        values = action[ViewModel::ActiveRecord::VALUES_ATTRIBUTE]
+        values&.each do |value|
+          migrate_tree!(value, references: references)
+        end
+      end
+    end
+
     def migrate_viewmodel!(view_name, source_version, view_hash, references)
       path = @paths[view_name]
       return false unless path

data/lib/view_model/record.rb

@@ -93,7 +93,7 @@ class ViewModel::Record < ViewModel
 
         if metadata.schema_version && !self.accepts_schema_version?(metadata.schema_version)
           raise ViewModel::DeserializationError::SchemaVersionMismatch.new(
-                  self, version, ViewModel::Reference.new(self, metadata.id))
+                  self, metadata.schema_version, ViewModel::Reference.new(self, metadata.id))
         end
 
         viewmodel = resolve_viewmodel(metadata, view_hash, deserialize_context: deserialize_context)
@@ -359,12 +359,20 @@ class ViewModel::Record < ViewModel
 
       attribute_changed!(vm_attr_name)
 
-      if attr_data.using_viewmodel? && !value.nil?
-        # Extract model from target viewmodel(s) to attach to our model
-        value = attr_data.map_value(value) { |vm| vm.model }
-      end
+      model_value =
+        if attr_data.using_viewmodel? && !value.nil?
+          # Extract model from target viewmodel(s) to attach to our model
+          attr_data.map_value(value) { |vm| vm.model }
+        else
+          value
+        end
+
+      model.public_send("#{attr_data.model_attr_name}=", model_value)
 
-      model.public_send("#{attr_data.model_attr_name}=", value)
+    elsif new_model?
+      # Record attribute_changed for mutable values asserted on a new model, even where
+      # they match the ActiveRecord default.
+      attribute_changed!(vm_attr_name) unless attr_data.read_only? && !attr_data.write_once?
     end
 
     if attr_data.using_viewmodel?

data/test/helpers/test_access_control.rb

@@ -13,6 +13,7 @@ class TestAccessControl < ViewModel::AccessControl
     @editable_checks   = []
     @visible_checks    = []
     @valid_edit_checks = []
+    @changes           = []
   end
 
   # Collect
@@ -33,6 +34,17 @@ class TestAccessControl < ViewModel::AccessControl
     ViewModel::AccessControl::Result.new(@can_view)
   end
 
+  def record_deserialize_changes(ref, changes)
+    @changes << [ref, changes]
+  end
+
+  # Collect all changes on after_deserialize, to allow inspecting changes that
+  # didn't result in `changed?`
+  after_deserialize do
+    ref = view.to_reference
+    record_deserialize_changes(ref, changes)
+  end
+
   # Query (also see attr_accessors)
 
   def valid_edit_refs
@@ -55,4 +67,10 @@ class TestAccessControl < ViewModel::AccessControl
   def was_edited?(ref)
     all_valid_edit_changes(ref).present?
   end
+
+  def all_changes(ref)
+    @changes
+      .select { |cref, _changes| cref == ref }
+      .map    { |_cref, changes| changes }
+  end
 end

data/test/helpers/viewmodel_spec_helpers.rb

@@ -206,6 +206,55 @@ module ViewModelSpecHelpers
     end
   end
 
+  module SingleWithInheritedMigration
+    extend ActiveSupport::Concern
+    include ViewModelSpecHelpers::Base
+
+    def migration_bearing_viewmodel_class
+      define_viewmodel_class(
+        :MigrationBearingView,
+        namespace: namespace,
+        viewmodel_base: viewmodel_base,
+        model_base: model_base,
+        spec: ViewModel::TestHelpers::ARVMBuilder::Spec.new(
+          schema: ->(_) {},
+          model: ->(_) {},
+          viewmodel: ->(v) {
+            root!
+            self.schema_version = 2
+            migrates from: 1, to: 2 do
+              down do |view, _refs|
+                view['inherited_base'] = 'present'
+              end
+            end
+          }))
+    end
+
+    def model_attributes
+      migration_bearing_viewmodel_class = self.migration_bearing_viewmodel_class
+
+      super.merge(
+        schema: ->(t) { t.integer :new_field, default: 1, null: false },
+        viewmodel: ->(_v) {
+          self.schema_version = 2
+
+          attribute :new_field
+
+          migrates from: 1, to: 2, inherit: migration_bearing_viewmodel_class, at: 2 do
+            down do |view, refs|
+              super(view, refs)
+              view.delete('new_field')
+            end
+
+            up do |view, refs|
+              view.delete('inherited_base')
+              view['new_field'] = 100
+            end
+          end
+        })
+    end
+  end
+
   module ParentAndBelongsToChildWithMigration
     extend ActiveSupport::Concern
     include ViewModelSpecHelpers::ParentAndBelongsToChild

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

@@ -178,6 +178,98 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
           end
         end
       end
+
+      describe 'with a functional update' do
+        # note that this wouldn't actually be deserializable as child is not a collection
+        def subject_data
+          data = super()
+          data['child'] = wrap_with_fupdate(data['child'])
+          data
+        end
+
+        def expected_result
+          data = super()
+          data['data']['child'] = wrap_with_fupdate(data['data']['child'])
+          data
+        end
+
+        def wrap_with_fupdate(child)
+          # The 'after' and remove shouldn't get changed in migration, even though it has _type: Child
+          build_fupdate do
+            append([child], after: { '_type' => 'Child', 'id' => 9999 })
+            update([child.deep_merge('id' => 8888)])
+            remove([{ '_type' => 'Child', 'id' => 7777 }])
+          end
+        end
+
+        it 'migrates' do
+          migrate!
+          assert_equal(expected_result, subject)
+        end
+      end
+    end
+  end
+
+  describe 'inherited migrations' do
+    include ViewModelSpecHelpers::SingleWithInheritedMigration
+
+    def new_model
+      model_class.new(name: 'm1')
+    end
+
+    let(:migration_versions) { { viewmodel_class => 1 } }
+
+    let(:v1_serialization_data) do
+      {
+        ViewModel::TYPE_ATTRIBUTE => viewmodel_class.view_name,
+        ViewModel::VERSION_ATTRIBUTE => 1,
+        ViewModel::ID_ATTRIBUTE => viewmodel.id,
+        'name' => viewmodel.name,
+        'inherited_base' => 'present',
+      }
+    end
+
+    let(:v1_serialization_references) { {} }
+
+    let(:v1_serialization) do
+      {
+        'data' => v1_serialization_data,
+        'references' => v1_serialization_references,
+      }
+    end
+
+    describe 'downwards' do
+      let(:migrator) { down_migrator }
+      let(:subject) { current_serialization.deep_dup }
+      let(:expected_result) do
+        v1_serialization.deep_merge({ 'data' => { ViewModel::MIGRATED_ATTRIBUTE => true } })
+      end
+
+      it 'migrates' do
+        migrate!
+        assert_equal(expected_result, subject)
+      end
+    end
+
+    describe 'upwards' do
+      let(:migrator) { up_migrator }
+      let(:subject) { v1_serialization.deep_dup }
+
+      let(:expected_result) do
+        current_serialization.deep_merge(
+          {
+            'data' => {
+              ViewModel::MIGRATED_ATTRIBUTE => true,
+              'new_field' => 100,
+            },
+          },
+        )
+      end
+
+      it 'migrates' do
+        migrate!
+        assert_equal(expected_result, subject)
+      end
     end
   end
 

data/test/unit/view_model/record_test.rb

@@ -57,11 +57,30 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
     let(:model_body)     { nil }
     let(:viewmodel_body) { nil }
 
+    # Generate an ActiveModel-like keyword argument constructor.
+    def generate_model_constructor(model_class, model_defaults)
+      args = model_class.members
+      params = args.map do |arg_name|
+        "#{arg_name}: self.class.__constructor_default(:#{arg_name})"
+      end
+
+      <<-SRC
+        def initialize(#{params.join(", ")})
+          super(#{args.join(", ")})
+        end
+      SRC
+    end
+
     let(:model_class) do
       mb = model_body
-      Struct.new(*attributes.keys) do
-        class_eval(&mb) if mb
-      end
+      mds = model_defaults
+
+      model = Struct.new(*attributes.keys)
+      constructor = generate_model_constructor(model, mds)
+      model.class_eval(constructor)
+      model.define_singleton_method(:__constructor_default) { |name| mds[name] }
+      model.class_eval(&mb) if mb
+      model
     end
 
     let(:viewmodel_class) do
@@ -96,21 +115,39 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       end
     end
 
-    let(:default_values) { {} }
-    let(:default_view_values) { default_values }
-    let(:default_model_values) { default_values }
+    # Default values for each model attribute, nil if absent
+    let(:model_defaults) { {} }
 
-    let(:default_view) do
-      attribute_names.each_with_object(view_base.dup) do |(model_attr_name, vm_attr_name), view|
-        view[vm_attr_name] = default_view_values.fetch(vm_attr_name.to_sym, model_attr_name)
-      end
+    # attribute values used to instantiate the subject model and subject view (if not overridden)
+    let(:subject_attributes) { {} }
+
+    # attribute values used to instantiate the subject model
+    let(:subject_model_attributes) { subject_attributes }
+
+    # attribute values used to deserialize the subject view: these are expected to
+    # deserialize to create a model equal to subject_model
+    let(:subject_view_attributes) { subject_attributes }
+
+    # Subject model to compare with or deserialize into
+    let(:subject_model) do
+      model_class.new(**subject_model_attributes)
+    end
+
+    # View that when deserialized into a new model will be equal to subject_model
+    let(:subject_view) do
+      view_base.merge(subject_view_attributes.stringify_keys)
     end
 
-    let(:default_model) do
-      attr_values = attribute_names.map do |model_attr_name, _vm_attr_name|
-        default_model_values.fetch(model_attr_name.to_sym, model_attr_name)
+    # The expected result of serializing subject_model (depends on subject_view corresponding to subject_model)
+    let(:expected_view) do
+      view = subject_view.dup
+      attribute_names.each do |model_attr_name, vm_attr_name|
+        unless view.has_key?(vm_attr_name)
+          expected_value = subject_model_attributes.fetch(model_attr_name) { model_defaults[model_attr_name] }
+          view[vm_attr_name] = expected_value
+        end
       end
-      model_class.new(*attr_values)
+      view
     end
 
     let(:access_control) { TestAccessControl.new(true, true, true) }
@@ -118,7 +155,7 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
     let(:create_context) { TestDeserializeContext.new(access_control: access_control) }
 
     # Prime our simplistic `resolve_viewmodel` with the desired models to update
-    let(:update_context) { TestDeserializeContext.new(targets: [default_model], access_control: access_control) }
+    let(:update_context) { TestDeserializeContext.new(targets: [subject_model], access_control: access_control) }
 
     def assert_edited(vm, **changes)
       ref = vm.to_reference
@@ -139,9 +176,9 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       def self.included(base)
         base.instance_eval do
           it 'can deserialize to a new model' do
-            vm = viewmodel_class.deserialize_from_view(default_view, deserialize_context: create_context)
-            assert_equal(default_model, vm.model)
-            refute(default_model.equal?(vm.model))
+            vm = viewmodel_class.deserialize_from_view(subject_view, deserialize_context: create_context)
+            assert_equal(subject_model, vm.model)
+            refute(subject_model.equal?(vm.model))
 
             all_view_attrs = attribute_names.map { |_mname, vname| vname }
             assert_edited(vm, new: true, changed_attributes: all_view_attrs)
@@ -154,8 +191,8 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       def self.included(base)
         base.instance_eval do
           it 'can deserialize to existing model with no changes' do
-            vm = viewmodel_class.deserialize_from_view(default_view, deserialize_context: update_context)
-            assert(default_model.equal?(vm.model))
+            vm = viewmodel_class.deserialize_from_view(subject_view, deserialize_context: update_context)
+            assert(subject_model.equal?(vm.model))
 
             assert_unchanged(vm)
           end
@@ -167,8 +204,8 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       def self.included(base)
         base.instance_eval do
           it 'can serialize to the expected view' do
-            h = viewmodel_class.new(default_model).to_hash
-            assert_equal(default_view, h)
+            h = viewmodel_class.new(subject_model).to_hash
+            assert_equal(expected_view, h)
           end
         end
       end
@@ -176,37 +213,48 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
 
     describe 'with simple attribute' do
       let(:attributes) { { simple: {} } }
+      let(:subject_attributes) { { simple: "simple" } }
+
       include CanSerialize
       include CanDeserializeToNew
       include CanDeserializeToExisting
 
       it 'can be updated' do
-        new_view = default_view.merge('simple' => 'changed')
+        update_view = subject_view.merge('simple' => 'changed')
 
-        vm = viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
+        vm = viewmodel_class.deserialize_from_view(update_view, deserialize_context: update_context)
 
-        assert(default_model.equal?(vm.model), 'returned model was not the same')
-        assert_equal('changed', default_model.simple)
+        assert(subject_model.equal?(vm.model), 'returned model was not the same')
+        assert_equal('changed', subject_model.simple)
         assert_edited(vm, changed_attributes: [:simple])
       end
 
       it 'rejects unknown attributes' do
-        view = default_view.merge('unknown' => 'illegal')
+        view = subject_view.merge('unknown' => 'illegal')
         ex = assert_raises(ViewModel::DeserializationError::UnknownAttribute) do
           viewmodel_class.deserialize_from_view(view, deserialize_context: create_context)
         end
         assert_equal('unknown', ex.attribute)
       end
 
+      it 'rejects unknown versions' do
+        view = subject_view.merge(ViewModel::VERSION_ATTRIBUTE => 100)
+        ex = assert_raises(ViewModel::DeserializationError::SchemaVersionMismatch) do
+          viewmodel_class.deserialize_from_view(view, deserialize_context: create_context)
+        end
+      end
+
       it 'edit checks when creating empty' do
         vm = viewmodel_class.deserialize_from_view(view_base, deserialize_context: create_context)
-        refute(default_model.equal?(vm.model), 'returned model was the same')
+        refute(subject_model.equal?(vm.model), 'returned model was the same')
         assert_edited(vm, new: true)
       end
     end
 
     describe 'with validated simple attribute' do
       let(:attributes) { { validated: {} } }
+      let(:subject_attributes) { { validated: "validated" } }
+
       let(:viewmodel_body) do
         ->(_x) do
           def validate!
@@ -222,10 +270,10 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       include CanDeserializeToExisting
 
       it 'rejects update when validation fails' do
-        new_view = default_view.merge('validated' => 'naughty')
+        update_view = subject_view.merge('validated' => 'naughty')
 
         ex = assert_raises(ViewModel::DeserializationError::Validation) do
-          viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
+          viewmodel_class.deserialize_from_view(update_view, deserialize_context: update_context)
         end
         assert_equal('validated', ex.attribute)
         assert_equal('was naughty', ex.reason)
@@ -234,16 +282,16 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
 
     describe 'with renamed attribute' do
       let(:attributes) { { modelname: { as: :viewname } } }
-      let(:default_model_values) { { modelname: 'value' } }
-      let(:default_view_values)  { { viewname: 'value' } }
+      let(:subject_model_attributes) { { modelname: 'value' } }
+      let(:subject_view_attributes)  { { viewname: 'value' } }
 
       include CanSerialize
       include CanDeserializeToNew
       include CanDeserializeToExisting
 
       it 'makes attributes available on their new names' do
-        value(default_model.modelname).must_equal('value')
-        vm = viewmodel_class.new(default_model)
+        value(subject_model.modelname).must_equal('value')
+        vm = viewmodel_class.new(subject_model)
         value(vm.viewname).must_equal('value')
       end
     end
@@ -251,15 +299,15 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
     describe 'with formatted attribute' do
       let(:attributes) { { moment: { format: IknowParams::Serializer::Time } } }
       let(:moment) { 1.week.ago.change(usec: 0) }
-      let(:default_model_values) { { moment: moment } }
-      let(:default_view_values)  { { moment: moment.iso8601 } }
+      let(:subject_model_attributes) { { moment: moment } }
+      let(:subject_view_attributes)  { { moment: moment.iso8601 } }
 
       include CanSerialize
       include CanDeserializeToNew
       include CanDeserializeToExisting
 
       it 'raises correctly on an unparseable value' do
-        bad_view = default_view.tap { |v| v['moment'] = 'not a timestamp' }
+        bad_view = subject_view.merge('moment' => 'not a timestamp')
         ex = assert_raises(ViewModel::DeserializationError::Validation) do
           viewmodel_class.deserialize_from_view(bad_view, deserialize_context: create_context)
         end
@@ -268,7 +316,7 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       end
 
       it 'raises correctly on an undeserializable value' do
-        bad_model = default_model.tap { |m| m.moment = 2.7 }
+        bad_model = subject_model.tap { |m| m.moment = 2.7 }
         ex = assert_raises(ViewModel::SerializationError) do
           viewmodel_class.new(bad_model).to_hash
         end
@@ -278,36 +326,51 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
 
     describe 'with read-only attribute' do
       let(:attributes) { { read_only: { read_only: true } } }
+      let(:model_defaults) { { read_only: 'immutable' } }
+      let(:subject_attributes) { { read_only: 'immutable' } }
 
-      include CanSerialize
-      include CanDeserializeToExisting
+      describe 'asserting the default' do
+        include CanSerialize
+        include CanDeserializeToExisting
 
-      it 'deserializes to new without the attribute' do
-        new_view = default_view.tap { |v| v.delete('read_only') }
-        vm = viewmodel_class.deserialize_from_view(new_view, deserialize_context: create_context)
-        refute(default_model.equal?(vm.model))
-        assert_nil(vm.model.read_only)
-        assert_edited(vm, new: true)
-      end
+        it 'deserializes to new with the attribute' do
+          vm = viewmodel_class.deserialize_from_view(subject_view, deserialize_context: create_context)
+          assert_equal(subject_model, vm.model)
+          refute(subject_model.equal?(vm.model))
+          assert_edited(vm, new: true)
+        end
 
-      it 'rejects deserialize from new' do
-        ex = assert_raises(ViewModel::DeserializationError::ReadOnlyAttribute) do
-          viewmodel_class.deserialize_from_view(default_view, deserialize_context: create_context)
+        it 'deserializes to new without the attribute' do
+          new_view = subject_view.tap { |v| v.delete('read_only') }
+          vm = viewmodel_class.deserialize_from_view(new_view, deserialize_context: create_context)
+          assert_equal(subject_model, vm.model)
+          refute(subject_model.equal?(vm.model))
+          assert_edited(vm, new: true)
         end
-        assert_equal('read_only', ex.attribute)
       end
 
-      it 'rejects update if changed' do
-        new_view = default_view.merge('read_only' => 'written')
-        ex = assert_raises(ViewModel::DeserializationError::ReadOnlyAttribute) do
-          viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
+      describe 'attempting a change' do
+        let(:update_view) { subject_view.merge('read_only' => 'attempted change') }
+
+        it 'rejects deserialize from new' do
+          ex = assert_raises(ViewModel::DeserializationError::ReadOnlyAttribute) do
+            viewmodel_class.deserialize_from_view(update_view, deserialize_context: create_context)
+          end
+          assert_equal('read_only', ex.attribute)
+        end
+
+        it 'rejects update' do
+          ex = assert_raises(ViewModel::DeserializationError::ReadOnlyAttribute) do
+            viewmodel_class.deserialize_from_view(update_view, deserialize_context: update_context)
+          end
+          assert_equal('read_only', ex.attribute)
         end
-        assert_equal('read_only', ex.attribute)
       end
     end
 
     describe 'with read-only write-once attribute' do
       let(:attributes) { { write_once: { read_only: true, write_once: true } } }
+      let(:subject_attributes) { { write_once: 'frozen' } }
       let(:model_body) do
         ->(_x) do
           # For the purposes of testing, we assume a record is new and can be
@@ -323,7 +386,7 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       include CanDeserializeToExisting
 
       it 'rejects change to attribute' do
-        new_view = default_view.merge('write_once' => 'written')
+        new_view = subject_view.merge('write_once' => 'written')
         ex = assert_raises(ViewModel::DeserializationError::ReadOnlyAttribute) do
           viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
         end
@@ -331,10 +394,33 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       end
     end
 
+    describe 'with unspecified attributes falling back to the model default' do
+      let(:attributes) { { value: {} } }
+      let(:model_defaults) { { value: 5 } }
+      let(:subject_view_attributes)  { { } }
+      let(:subject_model_attributes) { { value: 5 } }
+
+      it 'can deserialize to a new model' do
+        vm = viewmodel_class.deserialize_from_view(subject_view, deserialize_context: create_context)
+        assert_equal(subject_model, vm.model)
+        refute(subject_model.equal?(vm.model))
+        assert_edited(vm, new: true, changed_attributes: [])
+      end
+    end
+
+    describe 'with model defaults being asserted' do
+      let(:attributes) { { value: {} } }
+      let(:model_defaults) { { value: 5 } }
+      let(:subject_attributes) { { value: 5 } }
+
+      include CanDeserializeToNew
+    end
+
     describe 'with custom serialization' do
       let(:attributes)           { { overridden: {} } }
-      let(:default_view_values)  { { overridden: 10 } }
-      let(:default_model_values) { { overridden: 5 } }
+      let(:subject_model_attributes) { { overridden: 5 } }
+      let(:subject_view_attributes)  { { overridden: 10 } }
+
       let(:viewmodel_body) do
         ->(_x) do
           def serialize_overridden(json, serialize_context:)
@@ -344,7 +430,7 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
           def deserialize_overridden(value, references:, deserialize_context:)
             before_value = model.overridden
             model.overridden = value.try { |v| Integer(v) / 2 }
-            attribute_changed!(:overridden) unless before_value == model.overridden
+            attribute_changed!(:overridden) unless !new_model? && before_value == model.overridden
           end
         end
       end
@@ -354,12 +440,12 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       include CanDeserializeToExisting
 
       it 'can be updated' do
-        new_view = default_view.merge('overridden' => '20')
+        new_view = subject_view.merge('overridden' => '20')
 
         vm = viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
 
-        assert(default_model.equal?(vm.model), 'returned model was not the same')
-        assert_equal(10, default_model.overridden)
+        assert(subject_model.equal?(vm.model), 'returned model was not the same')
+        assert_equal(10, subject_model.overridden)
 
         assert_edited(vm, changed_attributes: [:overridden])
       end
@@ -391,77 +477,102 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       end
 
       describe 'with nested viewmodel' do
-        let(:default_nested_model) { nested_model_class.new('member') }
-        let(:default_nested_view)  { view_base.merge('_type' => 'Nested', 'member' => 'member') }
+        let(:subject_nested_model) { nested_model_class.new('member') }
+        let(:subject_nested_view)  { view_base.merge('_type' => 'Nested', 'member' => 'member') }
 
         let(:attributes) { { simple: {}, nested: { using: nested_viewmodel_class } } }
 
-        let(:default_view_values)  { { nested: default_nested_view } }
-        let(:default_model_values) { { nested: default_nested_model } }
+        let(:subject_view_attributes)  { { nested: subject_nested_view } }
+        let(:subject_model_attributes) { { nested: subject_nested_model } }
 
         let(:update_context) do
-          TestDeserializeContext.new(targets: [default_model, default_nested_model],
-                                     access_control: access_control)
+          TestDeserializeContext.new(
+            targets: [subject_model, subject_nested_model],
+            access_control: access_control)
         end
 
         include CanSerialize
-        include CanDeserializeToNew
+
+        it 'can deserialize to a new model' do
+          vm = viewmodel_class.deserialize_from_view(subject_view, deserialize_context: create_context)
+          assert_equal(subject_model, vm.model)
+          refute(subject_model.equal?(vm.model))
+
+          assert_equal(subject_nested_model, vm.model.nested)
+          refute(subject_nested_model.equal?(vm.model.nested))
+
+          assert_edited(vm, new: true, changed_attributes: ['nested'], changed_nested_children: true)
+        end
+
         include CanDeserializeToExisting
 
         it 'can update the nested value' do
-          new_view = default_view.merge('nested' => default_nested_view.merge('member' => 'changed'))
+          new_view = subject_view.merge('nested' => subject_nested_view.merge('member' => 'changed'))
 
           vm = viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
 
-          assert(default_model.equal?(vm.model), 'returned model was not the same')
-          assert(default_nested_model.equal?(vm.model.nested), 'returned nested model was not the same')
+          assert(subject_model.equal?(vm.model), 'returned model was not the same')
+          assert(subject_nested_model.equal?(vm.model.nested), 'returned nested model was not the same')
 
-          assert_equal('changed', default_model.nested.member)
+          assert_equal('changed', subject_model.nested.member)
 
           assert_unchanged(vm)
+
+          # The parent is itself not `changed?`, but it must record that its children are
+          change = access_control.all_changes(vm.to_reference)[0]
+          assert_equal(ViewModel::Changes.new(changed_nested_children: true), change)
+
           assert_edited(vm.nested, changed_attributes: [:member])
         end
 
         it 'can replace the nested value' do
           # The value will be unified if it is different after deserialization
-          new_view = default_view.merge('nested' => default_nested_view.merge('member' => 'changed'))
+          new_view = subject_view.merge('nested' => subject_nested_view.merge('member' => 'changed'))
 
-          partial_update_context = TestDeserializeContext.new(targets: [default_model],
+          partial_update_context = TestDeserializeContext.new(targets: [subject_model],
                                                               access_control: access_control)
 
           vm = viewmodel_class.deserialize_from_view(new_view, deserialize_context: partial_update_context)
 
-          assert(default_model.equal?(vm.model), 'returned model was not the same')
-          refute(default_nested_model.equal?(vm.model.nested), 'returned nested model was the same')
+          assert(subject_model.equal?(vm.model), 'returned model was not the same')
+          refute(subject_nested_model.equal?(vm.model.nested), 'returned nested model was the same')
 
-          assert_edited(vm, new: false, changed_attributes: [:nested])
+          assert_edited(vm, new: false, changed_attributes: [:nested], changed_nested_children: true)
           assert_edited(vm.nested, new: true, changed_attributes: [:member])
         end
       end
 
       describe 'with array of nested viewmodel' do
-        let(:default_nested_model_1) { nested_model_class.new('member1') }
-        let(:default_nested_view_1)  { view_base.merge('_type' => 'Nested', 'member' => 'member1') }
+        let(:subject_nested_model_1) { nested_model_class.new('member1') }
+        let(:subject_nested_view_1)  { view_base.merge('_type' => 'Nested', 'member' => 'member1') }
 
-        let(:default_nested_model_2) { nested_model_class.new('member2') }
-        let(:default_nested_view_2)  { view_base.merge('_type' => 'Nested', 'member' => 'member2') }
+        let(:subject_nested_model_2) { nested_model_class.new('member2') }
+        let(:subject_nested_view_2)  { view_base.merge('_type' => 'Nested', 'member' => 'member2') }
 
         let(:attributes) { { simple: {}, nested: { using: nested_viewmodel_class, array: true } } }
 
-        let(:default_view_values)  { { nested: [default_nested_view_1, default_nested_view_2] } }
-        let(:default_model_values) { { nested: [default_nested_model_1, default_nested_model_2] } }
+        let(:subject_view_attributes)  { { nested: [subject_nested_view_1, subject_nested_view_2] } }
+        let(:subject_model_attributes) { { nested: [subject_nested_model_1, subject_nested_model_2] } }
 
         let(:update_context) {
-          TestDeserializeContext.new(targets: [default_model, default_nested_model_1, default_nested_model_2],
+          TestDeserializeContext.new(targets: [subject_model, subject_nested_model_1, subject_nested_model_2],
                                      access_control: access_control)
         }
 
         include CanSerialize
-        include CanDeserializeToNew
+
+        it 'can deserialize to a new model' do
+          vm = viewmodel_class.deserialize_from_view(subject_view, deserialize_context: create_context)
+          assert_equal(subject_model, vm.model)
+          refute(subject_model.equal?(vm.model))
+
+          assert_edited(vm, new: true, changed_attributes: ['nested'], changed_nested_children: true)
+        end
+
         include CanDeserializeToExisting
 
         it 'rejects change to attribute' do
-          new_view = default_view.merge('nested' => 'terrible')
+          new_view = subject_view.merge('nested' => 'terrible')
           ex = assert_raises(ViewModel::DeserializationError::InvalidAttributeType) do
             viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
           end
@@ -471,32 +582,37 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
         end
 
         it 'can edit a nested value' do
-          default_view['nested'][0]['member'] = 'changed'
-          vm = viewmodel_class.deserialize_from_view(default_view, deserialize_context: update_context)
-          assert(default_model.equal?(vm.model), 'returned model was not the same')
+          subject_view['nested'][0]['member'] = 'changed'
+          vm = viewmodel_class.deserialize_from_view(subject_view, deserialize_context: update_context)
+          assert(subject_model.equal?(vm.model), 'returned model was not the same')
           assert_equal(2, vm.model.nested.size)
-          assert(default_nested_model_1.equal?(vm.model.nested[0]))
-          assert(default_nested_model_2.equal?(vm.model.nested[1]))
+          assert(subject_nested_model_1.equal?(vm.model.nested[0]))
+          assert(subject_nested_model_2.equal?(vm.model.nested[1]))
 
           assert_unchanged(vm)
+
+          # The parent is itself not `changed?`, but it must record that its children are
+          change = access_control.all_changes(vm.to_reference)[0]
+          assert_equal(ViewModel::Changes.new(changed_nested_children: true), change)
+
           assert_edited(vm.nested[0], changed_attributes: [:member])
         end
 
         it 'can append a nested value' do
-          default_view['nested'] << view_base.merge('_type' => 'Nested', 'member' => 'member3')
+          subject_view['nested'] << view_base.merge('_type' => 'Nested', 'member' => 'member3')
 
-          vm = viewmodel_class.deserialize_from_view(default_view, deserialize_context: update_context)
+          vm = viewmodel_class.deserialize_from_view(subject_view, deserialize_context: update_context)
 
-          assert(default_model.equal?(vm.model), 'returned model was not the same')
+          assert(subject_model.equal?(vm.model), 'returned model was not the same')
           assert_equal(3, vm.model.nested.size)
-          assert(default_nested_model_1.equal?(vm.model.nested[0]))
-          assert(default_nested_model_2.equal?(vm.model.nested[1]))
+          assert(subject_nested_model_1.equal?(vm.model.nested[0]))
+          assert(subject_nested_model_2.equal?(vm.model.nested[1]))
 
           vm.model.nested.each_with_index do |nvm, i|
             assert_equal("member#{i + 1}", nvm.member)
           end
 
-          assert_edited(vm, changed_attributes: [:nested])
+          assert_edited(vm, changed_attributes: [:nested], changed_nested_children: true)
           assert_edited(vm.nested[2], new: true, changed_attributes: [:member])
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iknow_view_models
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.6.0
 platform: ruby
 authors:
 - iKnow Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-17 00:00:00.000000000 Z
+date: 2021-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord