iknow_view_models 2.8.4

data/lib/view_model/test_helpers/arvm_builder.rb

@@ -0,0 +1,111 @@
+class ViewModel::TestHelpers::ARVMBuilder
+  attr_reader :name, :model, :viewmodel, :namespace
+
+  # Building an ARVM requires three blocks, to define schema, model and
+  # viewmodel. Support providing these either in an spec argument or as a
+  # dsl-style builder.
+  Spec = Struct.new(:schema, :model, :viewmodel) do
+    def initialize(schema:, model:, viewmodel:)
+      super(schema, model, viewmodel)
+    end
+
+    def merge(schema: nil, model: nil, viewmodel: nil)
+      this_schema    = self.schema
+      this_model     = self.model
+      this_viewmodel = self.viewmodel
+
+      Spec.new(
+        schema: ->(t) do
+          this_schema.(t)
+          schema&.(t)
+        end,
+        model: ->(m) do
+          m.class_eval(&this_model)
+          model.try { |b| m.class_eval(&b) }
+        end,
+        viewmodel: ->(v) do
+          v.class_eval(&this_viewmodel)
+          viewmodel.try { |b| v.class_eval(&b) }
+        end)
+    end
+  end
+
+  def initialize(name, model_base: ApplicationRecord, viewmodel_base: ViewModelBase, namespace: Object, spec: nil, &block)
+    @model_base = model_base
+    @viewmodel_base = viewmodel_base
+    @namespace = namespace
+    @name = name.to_s.camelize
+    @no_viewmodel = false
+
+    if spec
+      define_schema(&spec.schema)
+      define_model(&spec.model)
+      define_viewmodel(&spec.viewmodel)
+    else
+      instance_eval(&block)
+    end
+
+    raise "Model not created in ARVMBuilder"     unless model
+    raise "Schema not created in ARVMBuilder"    unless model.table_exists?
+    raise "ViewModel not created in ARVMBuilder" unless (viewmodel || @no_viewmodel)
+
+    # Force the realization of the view model into the library's lookup
+    # table. If this doesn't happen the library may have conflicting entries in
+    # the deferred table, and will allow viewmodels to leak between tests.
+    unless @no_viewmodel || !(@viewmodel < ViewModel::Record)
+      resolved = ViewModel::Registry.for_view_name(viewmodel.view_name)
+      raise "Failed to register expected new class!" unless resolved == @viewmodel
+    end
+  end
+
+  def teardown
+    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!
+  end
+
+  private
+
+  def viewmodel_name
+    self.name + "View"
+  end
+
+  def define_schema(&block)
+    table_name = name.underscore.pluralize
+    ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{table_name} CASCADE")
+    ActiveRecord::Schema.define do
+      self.verbose = false
+      create_table(table_name, &block)
+    end
+  end
+
+  def define_model(&block)
+    model_name = name
+    _namespace = namespace
+    @model = Class.new(@model_base) do |c|
+      raise "Model already defined: #{model_name}" if _namespace.const_defined?(model_name, false)
+      _namespace.const_set(model_name, self)
+      class_eval(&block)
+      reset_column_information
+    end
+    @model
+  end
+
+  def define_viewmodel(&block)
+    vm_name = viewmodel_name
+    _namespace = namespace
+    @viewmodel = Class.new(@viewmodel_base) do |c|
+      raise "Viewmodel alreay defined: #{vm_name}" if _namespace.const_defined?(vm_name, false)
+      _namespace.const_set(vm_name, self)
+      class_eval(&block)
+    end
+    raise "help help" if @viewmodel.name.nil?
+    @viewmodel
+  end
+
+  def no_viewmodel
+    @no_viewmodel = true
+  end
+end

data/lib/view_model/traversal_context.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'view_model/access_control/tree'
+
+# Abstract base for Serialize and DeserializeContexts.
+class ViewModel::TraversalContext
+  class SharedContext
+    attr_reader :access_control, :callbacks
+
+    def initialize(access_control: ViewModel::AccessControl::Open.new, callbacks: [])
+      @access_control = access_control
+      # Access control is guaranteed to be run after callbacks that may have
+      # side-effects on the view.
+      pre_callbacks, post_callbacks = callbacks.partition { |c| c.class.updates_view? }
+      @callbacks = pre_callbacks + [access_control] + post_callbacks
+    end
+  end
+
+  def self.shared_context_class
+    SharedContext
+  end
+
+  attr_reader :shared_context
+  delegate :access_control, :callbacks, to: :shared_context
+
+  def self.new_child(*args)
+    self.allocate.tap { |c| c.initialize_as_child(*args) }
+  end
+
+  def initialize(shared_context: nil, **shared_context_params)
+    super()
+    @shared_context     = shared_context || self.class.shared_context_class.new(**shared_context_params)
+    @parent_context     = nil
+    @parent_viewmodel   = nil
+    @parent_association = nil
+    @root               = true
+  end
+
+  # Overloaded constructor for initialization of descendent node contexts.
+  # Shared context is the same, ancestry is established, and subclasses can
+  # override to maintain other node-specific state.
+  def initialize_as_child(shared_context:, parent_context:, parent_viewmodel:, parent_association:)
+    @shared_context     = shared_context
+    @parent_context     = parent_context
+    @parent_viewmodel   = parent_viewmodel
+    @parent_association = parent_association
+    @root               = false
+  end
+
+  def for_child(parent_viewmodel, association_name:, **rest)
+    self.class.new_child(
+      shared_context:     shared_context,
+      parent_context:     self,
+      parent_viewmodel:   parent_viewmodel,
+      parent_association: association_name,
+      **rest)
+  end
+
+  # Obtain a semi-independent context for descending through a shared reference:
+  # keep the same shared context, but drop any tree location specific local
+  # context (since a shared reference could equally have been reached via any
+  # parent)
+  def for_references
+    self.class.new(shared_context: shared_context)
+  end
+
+  def parent_context(idx = 0)
+    if idx == 0
+      @parent_context
+    else
+      @parent_context&.parent_context(idx - 1)
+    end
+  end
+
+  def parent_viewmodel(idx = 0)
+    if idx == 0
+      @parent_viewmodel
+    else
+      parent_context(idx - 1)&.parent_viewmodel
+    end
+  end
+
+  def parent_association(idx = 0)
+    if idx == 0
+      @parent_association
+    else
+      parent_context(idx - 1)&.parent_association
+    end
+  end
+
+  def parent_ref(idx = 0)
+    parent_viewmodel(idx)&.to_reference
+  end
+
+  def run_callback(hook, view, **args)
+    callbacks.each do |callback|
+      callback.run_callback(hook, view, self, **args)
+    end
+
+    if view.respond_to?(hook.dsl_viewmodel_callback_method)
+      view.public_send(hook.dsl_viewmodel_callback_method, hook.context_name => self, **args)
+    end
+  end
+
+  def root?
+    @root
+  end
+
+  def nearest_root
+    if root?
+      self
+    else
+      parent_context&.nearest_root
+    end
+  end
+
+  def nearest_root_viewmodel
+    if root?
+      raise RuntimeError.new("Attempted to find nearest root from a root context. This is probably not what you wanted.")
+    elsif parent_context.root?
+      parent_viewmodel
+    else
+      parent_context.nearest_root_viewmodel
+    end
+  end
+end

data/lib/view_model/utils.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class ViewModel::Utils
+  class << self
+    def wrap_one_or_many(obj)
+      return_array = array_like?(obj)
+      results = yield(Array.wrap(obj))
+      return_array ? results : results.first
+    end
+
+    def map_one_or_many(obj)
+      if array_like?(obj)
+        obj.map { |x| yield(x) }
+      else
+        yield(obj)
+      end
+    end
+
+    # Cover arrays and also Rails' array-like types.
+    def array_like?(obj)
+      obj.respond_to?(:to_ary)
+    end
+  end
+end

data/lib/view_model/utils/collections.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class ViewModel::Utils
+  module Collections
+    def self.count_by(enumerable)
+      enumerable.each_with_object({}) do |el, counts|
+        key = yield(el)
+
+        unless key.nil?
+          counts[key] = (counts[key] || 0) + 1
+        end
+      end
+    end
+
+    refine Array do
+      def contains_exactly?(other)
+        mine   = count_by { |x| x }
+        theirs = other.count_by { |x| x }
+        mine == theirs
+      end
+
+      def count_by(&by)
+        Collections.count_by(self, &by)
+      end
+
+      def duplicates_by(&by)
+        count_by(&by).delete_if { |_, count| count == 1 }
+      end
+
+      def duplicates
+        duplicates_by { |x| x }
+      end
+    end
+
+    refine Hash do
+      def count_by(&by)
+        Collections.count_by(self, &by)
+      end
+
+      def duplicates_by(&by)
+        count_by(&by).delete_if { |_, count| count == 1 }
+      end
+
+      def duplicates
+        duplicates_by { |x| x }
+      end
+    end
+  end
+end

data/test/helpers/arvm_test_models.rb

@@ -0,0 +1,59 @@
+require_relative "test_access_control.rb"
+
+require "iknow_view_models"
+require "view_model/active_record"
+require "view_model/active_record/controller"
+
+require "acts_as_manual_list"
+
+db_config_path = File.join(File.dirname(__FILE__), '../config/database.yml')
+db_config = YAML.load(File.open(db_config_path))
+raise "Test database configuration missing" unless db_config["test"]
+ActiveRecord::Base.establish_connection(db_config["test"])
+
+# Remove test tables if any exist
+%w[labels parents children targets poly_ones poly_twos owners
+     grand_parents categories tags parents_tags].each do |t|
+  ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{t} CASCADE")
+end
+
+# Set up transactional tests
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+end
+
+# Base class for models
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end
+
+# base class for viewmodels
+class ViewModelBase < ViewModel::ActiveRecord
+  self.abstract_class = true
+
+  class DeserializeContext < ViewModel::DeserializeContext
+    def initialize(can_view: true, can_edit: true, can_change: true, **params)
+      params[:access_control] ||= TestAccessControl.new(can_view, can_edit, can_change)
+      super(**params)
+    end
+
+    delegate :visible_checks, :editable_checks, :valid_edit_refs, :valid_edit_changes, :all_valid_edit_changes, :was_edited?, to: :access_control
+  end
+
+  def self.deserialize_context_class
+    DeserializeContext
+  end
+
+  class SerializeContext < ViewModel::SerializeContext
+    def initialize(can_view: true, **params)
+      params[:access_control] ||= TestAccessControl.new(can_view, false, false)
+      super(**params)
+    end
+
+    delegate :visible_checks, :editable_checks, :valid_edit_refs, :valid_edit_changes, :all_valid_edit_changes, to: :access_control
+  end
+
+  def self.serialize_context_class
+    SerializeContext
+  end
+end

data/test/helpers/arvm_test_utilities.rb

@@ -0,0 +1,187 @@
+require 'active_support'
+require 'minitest/hooks'
+
+require 'view_model'
+require 'view_model/test_helpers'
+
+require_relative 'query_logging.rb'
+
+ActiveSupport::TestCase.include(Minitest::Hooks)
+
+module ARVMTestUtilities
+  extend ActiveSupport::Concern
+  include ViewModel::TestHelpers
+  using ViewModel::Utils::Collections
+
+  def self.included(klass)
+    klass.include(QueryLogging)
+  end
+
+  def initialize(*)
+    @viewmodels = []
+    super
+  end
+
+  def after_all
+    @viewmodels.each(&:teardown)
+    @viewmodels.clear
+    super
+  end
+
+  def teardown
+    ActiveRecord::Base.logger = nil
+    super
+  end
+
+  def build_viewmodel(name, &block)
+    @viewmodels << ViewModel::TestHelpers::ARVMBuilder.new(name, &block)
+  end
+
+  def serialize_with_references(serializable, serialize_context: ViewModelBase.new_serialize_context)
+    super(serializable, serialize_context: serialize_context)
+  end
+
+  def serialize(serializable, serialize_context: ViewModelBase.new_serialize_context)
+    super(serializable, serialize_context: serialize_context)
+  end
+
+  # Construct an update hash that references an existing model. Does not include
+  # any of the model's attributes or association.
+  def update_hash_for(viewmodel_class, model)
+    refhash = { '_type' => viewmodel_class.view_name, 'id' => model.id }
+    yield(refhash) if block_given?
+    refhash
+  end
+
+  # Test helper: update a model by constructing a new view hash
+  # TODO the body of this is growing longer and is mostly the same as by `alter_by_view!`.
+  def set_by_view!(viewmodel_class, model)
+    models = Array.wrap(model)
+
+    data = models.map { |m| update_hash_for(viewmodel_class, m) }
+    refs = {}
+
+    if model.is_a?(Array)
+      yield(data, refs)
+    else
+      yield(data.first, refs)
+    end
+
+    begin
+      deserialize_context = ViewModelBase::DeserializeContext.new
+
+      viewmodel_class.deserialize_from_view(
+        data, references: refs, deserialize_context: ViewModelBase::DeserializeContext.new)
+
+      deserialize_context
+    ensure
+      models.each { |m| m.reload }
+    end
+  end
+
+  def count_all(enum)
+    enum.count_by { |x| x }
+  end
+
+  def enable_logging!
+    if ENV['DEBUG']
+      ActiveRecord::Base.logger = Logger.new(STDERR)
+    end
+  end
+
+  def assert_serializes(vm, model, serialize_context: vm.new_serialize_context)
+    h = vm.new(model).to_hash(serialize_context: serialize_context)
+    assert_kind_of(Hash, h)
+    refs = serialize_context.serialize_references_to_hash
+    assert_kind_of(Hash, refs)
+  end
+
+  def refute_serializes(vm, model, message = nil, serialize_context: vm.new_serialize_context)
+    ex = assert_raises(ViewModel::AccessControlError) do
+      vm.new(model).to_hash(serialize_context: serialize_context)
+      serialize_context.serialize_references_to_hash
+    end
+    assert_match(message, ex.message) if message
+    ex
+  end
+
+  def assert_deserializes(vm, model,
+                          deserialize_context: vm.new_deserialize_context,
+                          serialize_context: vm.new_serialize_context,
+                          &block)
+    alter_by_view!(vm, model,
+                   deserialize_context: deserialize_context,
+                   serialize_context:   serialize_context,
+                   &block)
+  end
+
+  def refute_deserializes(vm, model, message = nil,
+                          deserialize_context: vm.new_deserialize_context,
+                          serialize_context: vm.new_serialize_context,
+                          &block)
+    ex = assert_raises(ViewModel::AccessControlError) do
+      alter_by_view!(vm, model,
+                     deserialize_context: deserialize_context,
+                     serialize_context:   serialize_context,
+                     &block)
+    end
+    assert_match(message, ex.message) if message
+    ex
+  end
+
+  class FupdateBuilder
+    class DSL
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def append(hashes, **rest)
+        @builder.append_action(
+          type:   ViewModel::ActiveRecord::FunctionalUpdate::Append,
+          values: hashes,
+          **rest)
+      end
+
+      def remove(hashes)
+        @builder.append_action(
+          type:   ViewModel::ActiveRecord::FunctionalUpdate::Remove,
+          values: hashes)
+      end
+
+      def update(hashes)
+        @builder.append_action(
+          type:   ViewModel::ActiveRecord::FunctionalUpdate::Update,
+          values: hashes)
+      end
+    end
+
+    def initialize
+      @actions = []
+    end
+
+    def append_action(type:, values:, **rest)
+      @actions.push(
+        {
+          ViewModel::ActiveRecord::TYPE_ATTRIBUTE   => type::NAME,
+          ViewModel::ActiveRecord::VALUES_ATTRIBUTE => values,
+        }.merge(rest.transform_keys(&:to_s))
+      )
+    end
+
+    def build!(&block)
+      DSL.new(self).instance_eval(&block)
+
+      {
+        ViewModel::ActiveRecord::TYPE_ATTRIBUTE    =>
+          ViewModel::ActiveRecord::FUNCTIONAL_UPDATE_TYPE,
+
+        ViewModel::ActiveRecord::ACTIONS_ATTRIBUTE =>
+          @actions,
+      }
+    end
+  end
+
+  def build_fupdate(attrs = {}, &block)
+    FupdateBuilder.new.build!(&block).merge(attrs)
+  end
+end