iknow_view_models 3.5.1 → 3.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b538a2d547114ecfbb76bfc790daea11b2185abdbad54d5da82723bb7fa1bef
-  data.tar.gz: 97b7e6d1d66cae14d56fe53931d06a4079e5c9b4b61e60bf56027d539fd41224
+  metadata.gz: 7f05051b924e9602a09da08b3aec5e5c4de224753d70d29523d66eb34db6947f
+  data.tar.gz: aac9f7453c54bb216d3cf59b438070c2857f186138c8ff871abaf026a94e4ab4
 SHA512:
-  metadata.gz: 4f70185a7ba12a222eee6a1549f724c08754f7213a1c1594d5b2ea0060baac04fce839cb480615e02741adcc82cd2d910e8d82e519127da15efd6e14dbdf3b0b
-  data.tar.gz: 82a343d49bf61a6e351653c8a3e3855344b5dd017acc7722cc526e41af8915d6aedb028995f859354df23de82f55b2c342b2fa1a572af76b1690345fb120ae02
+  metadata.gz: 3edbbb12ef310f58fea255589d2e2112cc62760518af31628c1121b0ea1db9634cb5ace9657087bceecd7f1bd38188fe9bec8b7e03c88613b773fafd2c6b7b6a
+  data.tar.gz: b063d4884cf2846bef6baca22bbc7f8533ddb2c876bf5ffa5e456a5834d7729881b0d08aab69ff524b5cf0fd451599346cce022502334f2bba26673b753a8068

data/.circleci/config.yml

@@ -121,6 +121,11 @@ workflows:
           ruby-version: "3.0"
           pg-version: "12"
           gemfile: gemfiles/rails_6_1.gemfile
+      - test:
+          name: 'ruby 3.0 rails 7.0 pg 12'
+          ruby-version: "3.0"
+          pg-version: "12"
+          gemfile: gemfiles/rails_7_0.gemfile
       - publish:
           filters:
             branches:

data/Appraisals

@@ -12,3 +12,8 @@ appraise 'rails-6-1' do
   gem 'activerecord', '~> 6.1.0'
   gem 'activesupport', '~> 6.1.0'
 end
+
+appraise 'rails-7-0' do
+  gem 'activerecord', '~> 7.0.0'
+  gem 'activesupport', '~> 7.0.0'
+end

data/Gemfile

@@ -11,5 +11,5 @@ gem 'rubocop-iknow'
 gem 'minitest-ci'
 
 # Override gemspec for development version preferences
-gem 'activerecord',  '~> 6.0.0'
-gem 'activesupport', '~> 6.0.0'
+gem 'activerecord',  '~> 7.0.0'
+gem 'activesupport', '~> 7.0.0'

data/gemfiles/rails_7_0.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem 'minitest-ci'
+gem "activerecord", "~> 7.0.0"
+gem "activesupport", "~> 7.0.0"
+
+gemspec path: '../'

data/lib/iknow_view_models/version.rb

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

data/lib/view_model/active_record/update_context.rb

@@ -14,9 +14,9 @@ class ViewModel::ActiveRecord
       def release!
         model = viewmodel.model
         case association_data.direct_reflection.options[:dependent]
-        when :delete
+        when :delete, :delete_all
           model.delete
-        when :destroy
+        when :destroy, :destroy_async
           model.destroy
         end
       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/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/lib/view_model/test_helpers/arvm_builder.rb

@@ -65,8 +65,11 @@ class ViewModel::TestHelpers::ARVMBuilder
     ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{name.underscore.pluralize} CASCADE")
     namespace.send(:remove_const, name)
     namespace.send(:remove_const, viewmodel_name) if viewmodel
+
     # prevent cached old class from being used to resolve associations
-    ActiveSupport::Dependencies::Reference.clear!
+    if ActiveSupport::VERSION::MAJOR < 7
+      ActiveSupport::Dependencies::Reference.clear!
+    end
   end
 
   private

data/nix/dependencies.nix

@@ -1,5 +1,5 @@
 {pkgs}:
 {
-  ruby = pkgs.ruby_2_7;
+  ruby = pkgs.ruby_3_0;
   postgresql = pkgs.postgresql_12;
 }

data/test/helpers/controller_test_helpers.rb

@@ -323,7 +323,11 @@ module ControllerTestControllers
     CONTROLLER_NAMES.each do |name|
       Object.send(:remove_const, name)
     end
-    ActiveSupport::Dependencies::Reference.clear!
+
+    if ActiveSupport::VERSION::MAJOR < 7
+      ActiveSupport::Dependencies::Reference.clear!
+    end
+
     super
   end
 end

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

@@ -210,6 +210,69 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
     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
+
   describe 'garbage collection' do
     include ViewModelSpecHelpers::ParentAndSharedBelongsToChild
 

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
@@ -386,82 +472,111 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       def teardown
         Object.send(:remove_const, :Nested)
         Object.send(:remove_const, :NestedView)
-        ActiveSupport::Dependencies::Reference.clear!
+
+        if ActiveSupport::VERSION::MAJOR < 7
+          ActiveSupport::Dependencies::Reference.clear!
+        end
+
         super
       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 +586,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.1
+  version: 3.6.1
 platform: ruby
 authors:
 - iKnow Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-07 00:00:00.000000000 Z
+date: 2022-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -380,6 +380,7 @@ files:
 - gemfiles/rails_5_2.gemfile
 - gemfiles/rails_6_0.gemfile
 - gemfiles/rails_6_1.gemfile
+- gemfiles/rails_7_0.gemfile
 - iknow_view_models.gemspec
 - lib/iknow_view_models.rb
 - lib/iknow_view_models/railtie.rb