iknow_view_models 3.1.8 → 3.2.4

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

@@ -1,9 +1,11 @@
-require_relative "../../../helpers/arvm_test_utilities.rb"
-require_relative "../../../helpers/arvm_test_models.rb"
+# frozen_string_literal: true
 
-require "minitest/autorun"
+require_relative '../../../helpers/arvm_test_utilities'
+require_relative '../../../helpers/arvm_test_models'
 
-require "view_model/active_record"
+require 'minitest/autorun'
+
+require 'view_model/active_record'
 
 class ViewModel::ActiveRecord::VersionTest < ActiveSupport::TestCase
   include ARVMTestUtilities
@@ -69,14 +71,14 @@ class ViewModel::ActiveRecord::VersionTest < ActiveSupport::TestCase
                      'id'       => @parent_with_a.child.id,
                      '_version' => 10,
                    },
-                   'target'   => { '_ref' => target_ref } },
+                   'target' => { '_ref' => target_ref } },
                  data)
 
     assert_equal({ target_ref =>
                      {
                        '_type'    => 'Target',
                        'id'       => @parent_with_a.target.id,
-                       '_version' => 20
+                       '_version' => 20,
                      } },
                  refs)
   end
@@ -86,7 +88,7 @@ class ViewModel::ActiveRecord::VersionTest < ActiveSupport::TestCase
       ParentView.deserialize_from_view(
         { '_type'    => 'Parent',
           '_new'     => true,
-          '_version' => 99 },)
+          '_version' => 99 })
     end
     assert_match(/schema version/, ex.message)
   end

data/test/unit/view_model/active_record_test.rb

@@ -1,12 +1,12 @@
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
 
-require_relative "../../helpers/arvm_test_utilities.rb"
-require_relative "../../helpers/arvm_test_models.rb"
+require_relative '../../helpers/arvm_test_utilities'
+require_relative '../../helpers/arvm_test_models'
 
-require "minitest/autorun"
+require 'minitest/autorun'
 require 'minitest/unit'
 
-require "view_model/active_record"
+require 'view_model/active_record'
 
 class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
   include ARVMTestUtilities
@@ -43,8 +43,8 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
   end
 
   def setup
-    @parent1 = Parent.create(name: "p1")
-    @parent2 = Parent.create(name: "p2")
+    @parent1 = Parent.create(name: 'p1')
+    @parent2 = Parent.create(name: 'p2')
 
     super
   end
@@ -80,8 +80,8 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
   def test_create_from_view
     view = {
-      "_type"    => "Parent",
-      "name"     => "p",
+      '_type'    => 'Parent',
+      'name'     => 'p',
     }
 
     pv = ParentView.deserialize_from_view(view)
@@ -90,7 +90,7 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
     assert(!p.changed?)
     assert(!p.new_record?)
 
-    assert_equal("p", p.name)
+    assert_equal('p', p.name)
   end
 
   def test_create_from_empty_view
@@ -101,10 +101,10 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
   def test_create_from_view_with_explicit_id
     view = {
-      "_type" => "Parent",
-      "id"    => 9999,
-      "name"  => "p",
-      "_new"  => true
+      '_type' => 'Parent',
+      'id'    => 9999,
+      'name'  => 'p',
+      '_new'  => true,
     }
     pv = ParentView.deserialize_from_view(view)
     p = pv.model
@@ -116,9 +116,9 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
   def test_create_explicit_id_raises_with_id
     view = {
-      "_type" => "Parent",
-      "id"    => 9999,
-      "_new"  => true
+      '_type' => 'Parent',
+      'id'    => 9999,
+      '_new'  => true,
     }
     ex = assert_raises(ViewModel::DeserializationError::DatabaseConstraint) do
       ParentView.deserialize_from_view(view)
@@ -129,15 +129,15 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
   def test_read_only_raises_with_id
     view = {
-      "_type" => "Parent",
-      "one"   => 2,
-      "id"    => 9999,
-      "_new"  => true
+      '_type' => 'Parent',
+      'one'   => 2,
+      'id'    => 9999,
+      '_new'  => true,
     }
     ex = assert_raises(ViewModel::DeserializationError::ReadOnlyAttribute) do
       ParentView.deserialize_from_view(view)
     end
-    assert_match("one", ex.attribute)
+    assert_match('one', ex.attribute)
     assert_equal([ViewModel::Reference.new(ParentView, 9999)], ex.nodes)
   end
 
@@ -151,7 +151,7 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
     assert_raises(ViewModel::AccessControlError) do
       no_view_context = ViewModelBase.new_deserialize_context(can_view: false)
-      ParentView.deserialize_from_view({'_type' => 'Parent', 'name' => 'p'},
+      ParentView.deserialize_from_view({ '_type' => 'Parent', 'name' => 'p' },
                                        deserialize_context: no_view_context)
     end
   end
@@ -167,7 +167,7 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
   def test_editability_checks_create_on_empty_record
     context = ViewModelBase.new_deserialize_context
-    view = TrivialView.deserialize_from_view({'_type' => 'Trivial' },
+    view = TrivialView.deserialize_from_view({ '_type' => 'Trivial' },
                                              deserialize_context: context)
 
     ref = view.to_reference
@@ -185,13 +185,13 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
     ex = assert_raises(ViewModel::AccessControlError) do
       # create
-      ParentView.deserialize_from_view({ "_type" => "Parent", "name" => "p" }, deserialize_context: no_edit_context)
+      ParentView.deserialize_from_view({ '_type' => 'Parent', 'name' => 'p' }, deserialize_context: no_edit_context)
     end
     assert_match(/Illegal edit/, ex.message)
 
     ex = assert_raises(ViewModel::AccessControlError) do
       # edit
-      v = ParentView.new(@parent1).to_hash.merge("name" => "p2")
+      v = ParentView.new(@parent1).to_hash.merge('name' => 'p2')
       ParentView.deserialize_from_view(v, deserialize_context: no_edit_context)
     end
     assert_match(/Illegal edit/, ex.message)
@@ -208,13 +208,13 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
     ex = assert_raises(ViewModel::AccessControlError) do
       # create
-      ParentView.deserialize_from_view({ "_type" => "Parent", "name" => "p" }, deserialize_context: no_edit_context)
+      ParentView.deserialize_from_view({ '_type' => 'Parent', 'name' => 'p' }, deserialize_context: no_edit_context)
     end
     assert_match(/Illegal edit/, ex.message)
 
     ex = assert_raises(ViewModel::AccessControlError) do
       # edit
-      v = ParentView.new(@parent1).to_hash.merge("name" => "p2")
+      v = ParentView.new(@parent1).to_hash.merge('name' => 'p2')
       ParentView.deserialize_from_view(v, deserialize_context: no_edit_context)
     end
     assert_match(/Illegal edit/, ex.message)
@@ -227,20 +227,20 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
   end
 
   def test_create_multiple
-    view = [{'_type' => 'Parent', 'name' => 'newp1'},
-            {'_type' => 'Parent', 'name' => 'newp2'}]
+    view = [{ '_type' => 'Parent', 'name' => 'newp1' },
+            { '_type' => 'Parent', 'name' => 'newp2' },]
 
     result = ParentView.deserialize_from_view(view)
 
-    new_parents = Parent.where(id: result.map{|x| x.model.id})
+    new_parents = Parent.where(id: result.map { |x| x.model.id })
 
-    assert_equal(%w{newp1 newp2}, new_parents.pluck(:name).sort)
+    assert_equal(%w[newp1 newp2], new_parents.pluck(:name).sort)
   end
 
   def test_update_duplicate_specification
     view = [
-      {'_type' => 'Parent', 'id' => @parent1.id},
-      {'_type' => 'Parent', 'id' => @parent1.id},
+      { '_type' => 'Parent', 'id' => @parent1.id },
+      { '_type' => 'Parent', 'id' => @parent1.id },
     ]
     assert_raises(ViewModel::DeserializationError::DuplicateNodes) do
       ParentView.deserialize_from_view(view)
@@ -248,28 +248,28 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
   end
 
   def test_create_invalid_type
-     build_viewmodel(:Invalid) do
+    build_viewmodel(:Invalid) do
       define_schema { |t| }
       define_model {}
       define_viewmodel {}
     end
 
     ex = assert_raises(ViewModel::DeserializationError::InvalidSyntax) do
-      ParentView.deserialize_from_view({ "target" => [] })
+      ParentView.deserialize_from_view({ 'target' => [] })
     end
     assert_match(/"_type" wasn't supplied/, ex.message)
 
-    ex = assert_raises(ViewModel::DeserializationError::InvalidViewType) do
-      ParentView.deserialize_from_view({ "_type" => "Invalid" })
+    assert_raises(ViewModel::DeserializationError::InvalidViewType) do
+      ParentView.deserialize_from_view({ '_type' => 'Invalid' })
     end
 
-    ex = assert_raises(ViewModel::DeserializationError::UnknownView) do
-      ParentView.deserialize_from_view({ "_type" => "NotAViewmodelType" })
+    assert_raises(ViewModel::DeserializationError::UnknownView) do
+      ParentView.deserialize_from_view({ '_type' => 'NotAViewmodelType' })
     end
   end
 
   def test_edit_attribute_from_view
-    alter_by_view!(ParentView, @parent1) do |view, refs|
+    alter_by_view!(ParentView, @parent1) do |view, _refs|
       view['name'] = 'renamed'
     end
     assert_equal('renamed', @parent1.name)
@@ -278,28 +278,28 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
   def test_edit_attribute_validation_failure
     old_name = @parent1.name
     ex = assert_raises(ViewModel::DeserializationError::Validation) do
-      alter_by_view!(ParentView, @parent1) do |view, refs|
+      alter_by_view!(ParentView, @parent1) do |view, _refs|
         view['name'] = 'invalid'
       end
     end
     assert_equal(old_name, @parent1.name, 'validation failure causes rollback')
-    assert_equal(ex.attribute, "name")
-    assert_equal(ex.reason, "invalid due to matching test sentinel")
+    assert_equal(ex.attribute, 'name')
+    assert_equal(ex.reason, 'invalid due to matching test sentinel')
   end
 
   def test_edit_readonly_attribute
     assert_raises(ViewModel::DeserializationError::ReadOnlyAttribute) do
-      ex = alter_by_view!(ParentView, @parent1) do |view, refs|
+      ex = alter_by_view!(ParentView, @parent1) do |view, _refs|
         view['one'] = 2
       end
-      assert_equal("one", ex.attribute)
+      assert_equal('one', ex.attribute)
     end
   end
 
   def test_edit_missing_root
     view = {
-      "_type" => "Parent",
-      "id"    => 9999
+      '_type' => 'Parent',
+      'id'    => 9999,
     }
 
     ex = assert_raises(ViewModel::DeserializationError::NotFound) do
@@ -310,7 +310,7 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
   end
 
   def test_optimistic_locking
-    @parent1.name = "changed"
+    @parent1.name = 'changed'
     @parent1.save!
 
     assert_raises(ViewModel::DeserializationError::LockFailure) do
@@ -320,7 +320,6 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
     end
   end
 
-
   # Tests for overriding the serialization of attributes using custom viewmodels
   class CustomAttributeViewsTests < ActiveSupport::TestCase
     include ARVMTestUtilities
@@ -334,7 +333,7 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
       end
 
       def self.deserialize_from_view(hash_data, references: {}, deserialize_context:)
-        array = [hash_data["a"], hash_data["b"]]
+        array = [hash_data['a'], hash_data['b']]
         self.new(array)
       end
     end
@@ -343,7 +342,7 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
       super
       build_viewmodel(:Pair) do
         define_schema do |t|
-          t.column :pair, "integer[]"
+          t.column :pair, 'integer[]'
         end
 
         define_model do
@@ -357,23 +356,23 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
     def setup
       super
-      @pair = Pair.create!(pair: [1,2])
+      @pair = Pair.create!(pair: [1, 2])
     end
 
     def test_serialize_view
       view, _refs = serialize_with_references(PairView.new(@pair))
 
-      assert_equal({ "_type"    => "Pair",
-                     "_version" => 1,
-                     "id"       => @pair.id,
-                     "pair"     => { "a" => 1, "b" => 2 } },
+      assert_equal({ '_type'    => 'Pair',
+                     '_version' => 1,
+                     'id'       => @pair.id,
+                     'pair'     => { 'a' => 1, 'b' => 2 } },
                    view)
     end
 
     def test_create
-      view = { "_type" => "Pair", "pair" => { "a" => 3, "b" => 4 } }
+      view = { '_type' => 'Pair', 'pair' => { 'a' => 3, 'b' => 4 } }
       pv = PairView.deserialize_from_view(view)
-      assert_equal([3,4], pv.model.pair)
+      assert_equal([3, 4], pv.model.pair)
     end
   end
 
@@ -383,8 +382,9 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
     class RefError < RuntimeError
       attr_reader :ref
+
       def initialize(ref)
-        super("Boom")
+        super('Boom')
         @ref = ref
       end
     end
@@ -405,7 +405,7 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
           association :child
           attribute :explode
           # Escape deserialization with the parent context
-          define_method(:deserialize_explode) do |val, references:, deserialize_context: |
+          define_method(:deserialize_explode) do |val, references:, deserialize_context:|
             raise RefError.new(deserialize_context.parent_ref) if val
           end
         end
@@ -418,22 +418,22 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
     def test_deserialize_context
       view = {
-        "_type" => "List",
-        "id"    => 1000,
-        "_new"  => true,
-        "child" => {
-          "_type" => "List",
-        }}
+        '_type' => 'List',
+        'id'    => 1000,
+        '_new'  => true,
+        'child' => {
+          '_type' => 'List',
+        } }
 
       ref_error = assert_raises(RefError) do
-        ListView.deserialize_from_view(view.deep_merge("child" => { "explode" => true }))
+        ListView.deserialize_from_view(view.deep_merge('child' => { 'explode' => true }))
       end
 
       assert_equal(ListView, ref_error.ref.viewmodel_class)
       assert_equal(1000, ref_error.ref.model_id)
 
       ref_error = assert_raises(RefError) do
-        ListView.deserialize_from_view(view.deep_merge("explode" => true))
+        ListView.deserialize_from_view(view.deep_merge('explode' => true))
       end
 
       assert_nil(ref_error.ref)
@@ -461,7 +461,7 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
           association :child
         end
       end
-      List.connection.execute("ALTER TABLE lists ADD CONSTRAINT unique_child UNIQUE (child_id) DEFERRABLE INITIALLY DEFERRED")
+      List.connection.execute('ALTER TABLE lists ADD CONSTRAINT unique_child UNIQUE (child_id) DEFERRABLE INITIALLY DEFERRED')
     end
 
     def test_deferred_constraint_violation
@@ -470,8 +470,8 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
 
       ex = assert_raises(ViewModel::DeserializationError::UniqueViolation) do
         alter_by_view!(ListView, l2) do |view, refs|
-          view['child'] = { "_ref" => "r1" }
-          refs["r1"] = { "_type" => "List", "id" => l1.child.id }
+          view['child'] = { '_ref' => 'r1' }
+          refs['r1'] = { '_type' => 'List', 'id' => l1.child.id }
         end
       end
 

data/test/unit/view_model/callbacks_test.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../../helpers/arvm_test_utilities.rb'
-require_relative '../../helpers/arvm_test_models.rb'
-require_relative '../../helpers/callback_tracer.rb'
-require_relative '../../helpers/viewmodel_spec_helpers.rb'
+require_relative '../../helpers/arvm_test_utilities'
+require_relative '../../helpers/arvm_test_models'
+require_relative '../../helpers/callback_tracer'
+require_relative '../../helpers/viewmodel_spec_helpers'
 
 require 'minitest/autorun'
 
@@ -62,7 +62,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
           [visit(ViewModel::Callbacks::Hook::BeforeVisit, vm),
            visit(ViewModel::Callbacks::Hook::BeforeVisit, vm.child),
            visit(ViewModel::Callbacks::Hook::AfterVisit,  vm.child),
-           visit(ViewModel::Callbacks::Hook::AfterVisit,  vm)])
+           visit(ViewModel::Callbacks::Hook::AfterVisit,  vm),])
       end
 
       it 'visits in correct order when deserializing' do
@@ -79,7 +79,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
 
            visit(ViewModel::Callbacks::Hook::BeforeValidate,    vm),
            visit(ViewModel::Callbacks::Hook::AfterDeserialize,  vm),
-           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm)])
+           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm),])
       end
 
       it 'calls edit hook when updating' do
@@ -99,7 +99,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
            visit(ViewModel::Callbacks::Hook::BeforeValidate,    vm),
            visit(ViewModel::Callbacks::Hook::OnChange,          vm),
            visit(ViewModel::Callbacks::Hook::AfterDeserialize,  vm),
-           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm)])
+           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm),])
       end
 
       it 'calls edit hook when deleting' do
@@ -122,7 +122,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
            visit(ViewModel::Callbacks::Hook::OnChange,          vm),
 
            visit(ViewModel::Callbacks::Hook::AfterDeserialize,  vm),
-           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm)])
+           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm),])
       end
 
       it 'calls hooks on old and new when replacing' do
@@ -153,7 +153,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
            visit(ViewModel::Callbacks::Hook::OnChange,          vm),
 
            visit(ViewModel::Callbacks::Hook::AfterDeserialize,  vm),
-           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm)])
+           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm),])
       end
 
       it 'calls hooks on old and new when moving' do
@@ -184,7 +184,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
            visit(ViewModel::Callbacks::Hook::BeforeValidate,    vm2),
            visit(ViewModel::Callbacks::Hook::OnChange,          vm2),
            visit(ViewModel::Callbacks::Hook::AfterDeserialize,  vm2),
-           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm2)])
+           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm2),])
       end
 
       it 'calls hooks on delete' do
@@ -195,7 +195,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
            visit(ViewModel::Callbacks::Hook::BeforeDeserialize, vm),
            visit(ViewModel::Callbacks::Hook::OnChange,          vm),
            visit(ViewModel::Callbacks::Hook::AfterDeserialize,  vm),
-           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm)])
+           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm),])
         ## At present, children aren't visited on delete.
         # visit(ViewModel::Callbacks::Hook::BeforeVisit,       old_child),
         # visit(ViewModel::Callbacks::Hook::BeforeDeserialize, old_child),
@@ -283,7 +283,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
 
            visit(ViewModel::Callbacks::Hook::OnChange,          vm),
            visit(ViewModel::Callbacks::Hook::AfterDeserialize,  vm),
-           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm)])
+           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm),])
       end
 
       it 'calls hooks on append_associated' do
@@ -306,7 +306,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
 
            visit(ViewModel::Callbacks::Hook::OnChange,          vm),
            visit(ViewModel::Callbacks::Hook::AfterDeserialize,  vm),
-           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm)])
+           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm),])
       end
 
       it 'calls hooks on delete_associated' do
@@ -330,7 +330,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
 
            visit(ViewModel::Callbacks::Hook::OnChange,          vm),
            visit(ViewModel::Callbacks::Hook::AfterDeserialize,  vm),
-           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm)])
+           visit(ViewModel::Callbacks::Hook::AfterVisit,        vm),])
       end
     end
 
@@ -386,6 +386,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
       class ViewSpecificCallback
         include ViewModel::Callbacks
         attr_reader :models, :children
+
         def initialize
           @models = []
           @children = []
@@ -422,6 +423,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
         include ViewModel::Callbacks
 
         attr_reader :events
+
         def initialize
           @events = []
         end
@@ -443,6 +445,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
         include ViewModel::Callbacks
 
         attr_reader :a
+
         def initialize
           @a = 0
         end
@@ -456,6 +459,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
 
       class ChildCallback < ParentCallback
         attr_reader :b
+
         def initialize
           super
           @b = 0
@@ -541,7 +545,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
         [RecordingCallback.new(events, :a),
          UpdatingCallback.new(events, :b),
          RecordingCallback.new(events, :c),
-         UpdatingCallback.new(events, :d)]
+         UpdatingCallback.new(events, :d),]
       end
 
       it 'calls callbacks in order specified partitioned by update' do