iknow_view_models 3.5.2 → 3.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f51edf25fab0aec533446c939c44975f76806871e1341518aa4470f32c23d839
-  data.tar.gz: 140166cc68f15484a0291f4e8faa8b4e26c3233a2b3bcfacfa9a4972a2a5e0ef
+  metadata.gz: 267212f1572c3f81b65462be6c30e02a12a6562a29d01bd5e0c342a12396acbc
+  data.tar.gz: e8c4addd984351d6df889ba7d75abbe8d5bde7793a48791e24a1b42e7a3fdf42
 SHA512:
-  metadata.gz: 27e85b3cd097d4f19e28d66d3500db4142dedd4a65a44731754afd35430d86945bb2e7f928df476e4aadb665d34518fa10211113f17b1ad0718727f957c8156f
-  data.tar.gz: 7e740ea172d15e55b870336fd833a6138c3f5aaec97da84828813b6da57d9512bbb3cd98f404f24c58c7adf7b53d875639bd22561b200d429e74523770a3a483
+  metadata.gz: 6039dcc05bed20bce4681c322c3509be3f2a276c0a755fb3e27240eec74fd9eddef68f3c272df33554407853065a98e0f4d03a068c8c0e068cfc02be6f73ab67
+  data.tar.gz: 95fb89d93724d5028905612d846534916c4bdacd1bb88009ae434090b183e17d7311bb2709bfa81b08ff3dff45940ced0ce080ff861529c59cbb96671a661b64

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,6 @@ 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'
+gem 'actionpack',    '~> 7.0.0'

data/gemfiles/rails_5_2.gemfile

@@ -5,5 +5,6 @@ source 'https://rubygems.org'
 gem 'minitest-ci'
 gem 'activerecord', '~> 5.2.0'
 gem 'activesupport', '~> 5.2.0'
+gem 'actionpack', '~> 5.2.0'
 
 gemspec path: '../'

data/gemfiles/rails_6_0.gemfile

@@ -5,5 +5,6 @@ source 'https://rubygems.org'
 gem 'minitest-ci'
 gem 'activerecord', '~> 6.0.0'
 gem 'activesupport', '~> 6.0.0'
+gem 'actionpack', '~> 6.0.0'
 
 gemspec path: '../'

data/gemfiles/rails_6_1.gemfile

@@ -5,5 +5,6 @@ source 'https://rubygems.org'
 gem 'minitest-ci'
 gem 'activerecord', '~> 6.1.0'
 gem 'activesupport', '~> 6.1.0'
+gem 'actionpack', '~> 6.1.0'
 
 gemspec path: '../'

data/gemfiles/rails_7_0.gemfile

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

data/iknow_view_models.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.7'
 
+  spec.add_dependency 'actionpack', '>= 5.0'
   spec.add_dependency 'activerecord', '>= 5.0'
   spec.add_dependency 'activesupport', '>= 5.0'
 

data/lib/iknow_view_models/version.rb

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

data/lib/view_model/access_control/composed.rb

@@ -39,7 +39,7 @@ class ViewModel::AccessControl::Composed < ViewModel::AccessControl
           case
           when new_allow
             nil
-          when self.allow_error && other.allow_error
+          when mergeable_error?(self.allow_error) && mergeable_error?(other.allow_error)
             self.allow_error.merge(other.allow_error)
           else
             self.allow_error || other.allow_error
@@ -48,6 +48,12 @@ class ViewModel::AccessControl::Composed < ViewModel::AccessControl
         ComposedResult.new(new_allow, other.veto, new_allow_error, other.veto_error)
       end
     end
+
+    private
+
+    def mergeable_error?(err)
+      err&.is_a?(NoRequiredConditionsError)
+    end
   end
 
   PermissionsCheck = Struct.new(:location, :reason, :error_type, :checker) do
@@ -196,22 +202,54 @@ class ViewModel::AccessControl::Composed < ViewModel::AccessControl
   protected
 
   def check_delegates(env, ifs, unlesses)
-    vetoed_checker = unlesses.detect { |checker| checker.check(env) }
+    veto, veto_error = detect_veto(env, unlesses)
+    allow, allow_error = detect_allow(env, ifs)
+
+    ComposedResult.new(allow, veto, allow_error, veto_error)
+  end
+
+  private
+
+  def detect_veto(env, checkers)
+    checkers.each do |checker|
+      result = checker.check(env)
+      next unless result
 
-    veto = vetoed_checker.present?
-    if veto
-      veto_error = vetoed_checker.error_type.new('Action not permitted because: ' +
-                                                 vetoed_checker.reason,
-                                                 env.view.blame_reference)
+      error =
+        if result.is_a?(StandardError)
+          result
+        else
+          checker.error_type.new('Action not permitted because: ' +
+                                 checker.reason,
+                                 env.view.blame_reference)
+        end
+
+      # short-circuit exit with failure
+      return true, error
     end
 
-    allow = ifs.any? { |checker| checker.check(env) }
+    return false, nil
+  end
+
+  def detect_allow(env, checkers)
+    error = nil
+
+    checkers.each do |checker|
+      result = checker.check(env)
+      next unless result
 
-    unless allow
-      allow_error = NoRequiredConditionsError.new(env.view.blame_reference,
-                                                  ifs.map(&:name))
+      if result.is_a?(StandardError)
+        error ||= result
+      else
+        # short-circuit exit with success
+        return true, nil
+      end
     end
 
-    ComposedResult.new(allow, veto, allow_error, veto_error)
+    error ||= NoRequiredConditionsError.new(
+      env.view.blame_reference,
+      checkers.map(&:name))
+
+    return false, error
   end
 end

data/lib/view_model/access_control.rb

@@ -149,6 +149,14 @@ class ViewModel::AccessControl
   def raise_if_error!(result)
     raise (result.error || yield) unless result.permit?
   end
+
+  # Called from composed access controls via the `env`, this is used to make the
+  # if/unless DSL more readable when returning a custom failure error.
+  def failure(err)
+    raise ArgumentError.new("Unexpected failure type: #{err}") unless err.is_a?(StandardError)
+
+    err
+  end
 end
 
 require 'view_model/access_control/open'

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

@@ -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/access_control_test.rb

@@ -156,6 +156,54 @@ class ViewModel::AccessControlTest < ActiveSupport::TestCase
       assert_equal(2, ex.reasons.count)
     end
 
+    def test_veto_ordering
+      TestAccessControl.visible_if!('always') { true }
+
+      TestAccessControl.visible_unless!('car starts with i') do
+        view.car =~ /^i/
+      end
+
+      TestAccessControl.visible_unless!('car ends with e') do
+        view.car =~ /e$/
+      end
+
+      assert_serializes(ListView, List.create!(car: 'ok'))
+      refute_serializes(ListView, List.create!(car: 'invisible'), /not permitted.*car starts with i/)
+    end
+
+    def test_custom_error_if
+      TestAccessControl.visible_if!('car is visible1') do
+        view.car == 'visible1' ||
+          # In principle a failure() may return any error, but by returning an
+          # AccessControlError we make it possible to test with refute_serializes
+          failure(ViewModel::AccessControlError.new('Custom Error Message', view.blame_reference))
+      end
+
+      TestAccessControl.visible_if!('car is visible2') do
+        view.car == 'visible2' ||
+          # Only the first failure() recorded by a failed if check will be
+          # raised as the error.
+          failure(ViewModel::AccessControlError.new('Should not be seen', view.blame_reference))
+      end
+
+      assert_serializes(ListView, List.create!(car: 'visible1'))
+      assert_serializes(ListView, List.create!(car: 'visible2'))
+      refute_serializes(ListView, List.create!(car: 'bad'), /Custom Error Message/)
+    end
+
+    def test_custom_error_unless
+      TestAccessControl.visible_if!('always') { true }
+
+      TestAccessControl.visible_unless!('car is invisible') do
+        if view.car == 'invisible'
+          failure(ViewModel::AccessControlError.new('Custom Error Message', view.blame_reference))
+        end
+      end
+
+      assert_serializes(ListView, List.create!(car: 'ok'))
+      refute_serializes(ListView, List.create!(car: 'invisible'), /Custom Error Message/)
+    end
+
     def test_inheritance
       child_access_control = Class.new(ViewModel::AccessControl::Composed)
       child_access_control.include_from(TestAccessControl)

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

@@ -15,16 +15,11 @@ require 'view_model/active_record'
 
 DUMMY_RAILS_CACHE = ActiveSupport::Cache::MemoryStore.new
 
-module RailsDummyCache
-  def cache
-    DUMMY_RAILS_CACHE
-  end
+IknowCache.configure! do
+  logger ::ActiveRecord::Base.logger
+  cache DUMMY_RAILS_CACHE
 end
 
-# Ensure we have a dummy Rails, and then prepend our dummy cache
-module Rails; end
-Rails.singleton_class.prepend(RailsDummyCache)
-
 class ViewModel::ActiveRecord
   class CacheTest < ActiveSupport::TestCase
     using ViewModel::Utils::Collections

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,22 +213,24 @@ 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
@@ -199,7 +238,7 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       end
 
       it 'rejects unknown versions' do
-        view = default_view.merge(ViewModel::VERSION_ATTRIBUTE => 100)
+        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
@@ -207,13 +246,15 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
 
       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!
@@ -229,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)
@@ -241,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
@@ -258,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
@@ -275,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
@@ -285,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
@@ -330,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
@@ -338,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:)
@@ -351,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
@@ -361,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
@@ -393,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
@@ -478,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,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: iknow_view_models
 version: !ruby/object:Gem::Version
-  version: 3.5.2
+  version: 3.6.2
 platform: ruby
 authors:
 - iKnow Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-28 00:00:00.000000000 Z
+date: 2022-02-16 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -380,6 +394,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