iknow_view_models 2.8.4

data/test/helpers/callback_tracer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class CallbackTracer
+  include ViewModel::Callbacks
+
+  Visit = Struct.new(:hook, :view) do
+    def inspect
+      "#{hook.name}(#{view.to_reference})"
+    end
+  end
+
+  attr_reader :hook_trace
+
+  def initialize
+    @hook_trace = []
+  end
+
+  ViewModel::Callbacks::Hook.each do |hook|
+    send(hook.dsl_add_hook_name) do
+      hook_trace << Visit.new(hook, view)
+    end
+  end
+
+  def log!
+    puts hook_trace.map { |t| [t.hook.name, t.view.class, t.view.model].inspect }
+  end
+end

data/test/helpers/controller_test_helpers.rb

@@ -0,0 +1,270 @@
+require "iknow_view_models"
+require "view_model/active_record"
+require "view_model/active_record/controller"
+
+require_relative "../helpers/arvm_test_utilities.rb"
+require_relative "../helpers/arvm_test_models.rb"
+
+require "acts_as_manual_list"
+
+# models for ARVM controller test
+module ControllerTestModels
+  def before_all
+    super
+
+    build_viewmodel(:Label) do
+      define_schema do |t|
+        t.string :text
+      end
+      define_model do
+        has_one :parent
+        has_one :target
+      end
+      define_viewmodel do
+        attributes :text
+      end
+    end
+
+    build_viewmodel(:Category) do
+      define_schema do |t|
+        t.string :name
+      end
+      define_model do
+        has_many :parents
+      end
+      define_viewmodel do
+        attributes :name
+      end
+    end
+
+    build_viewmodel(:PolyOne) do
+      define_schema do |t|
+        t.integer :number
+      end
+      define_model do
+        has_one :parent, as: :poly
+      end
+      define_viewmodel do
+        attributes :number
+      end
+    end
+
+    build_viewmodel(:PolyTwo) do
+      define_schema do |t|
+        t.string :text
+      end
+      define_model do
+        has_one :parent, as: :poly
+      end
+      define_viewmodel do
+        attributes :text
+      end
+    end
+
+    build_viewmodel(:Parent) do
+      define_schema do |t|
+        t.string     :name
+        t.references :label, foreign_key: true
+        t.string     :poly_type
+        t.integer    :poly_id
+        t.references :category, foreign_key: true # shared reference
+      end
+      define_model do
+        has_many   :children, dependent: :destroy, inverse_of: :parent
+        belongs_to :label,    dependent: :destroy
+        has_one    :target,   dependent: :destroy, inverse_of: :parent
+        belongs_to :poly, polymorphic: true, dependent: :destroy, inverse_of: :parent
+        belongs_to :category
+      end
+      define_viewmodel do
+        attributes   :name
+        associations :label, :target
+        association  :children, optional: true
+        association  :poly, viewmodels: [:PolyOne, :PolyTwo]
+        association  :category, shared: true
+      end
+    end
+
+    build_viewmodel(:Child) do
+      define_schema do |t|
+        t.references :parent, null: false, foreign_key: true
+        t.string     :name
+        t.float      :position
+      end
+      # Add age column separately in order to define CHECK constraint (no way to
+      # specify in activerecord schema.
+      ActiveRecord::Base.connection.execute(<<-SQL)
+        ALTER TABLE children ADD COLUMN age integer CHECK(age > 21)
+      SQL
+      define_model do
+        belongs_to :parent, inverse_of: :children
+        acts_as_manual_list scope: :parent
+        validates :age, numericality: {less_than: 42}, allow_nil: true
+      end
+      define_viewmodel do
+        attributes :name, :age
+        acts_as_list :position
+      end
+    end
+
+    build_viewmodel(:Target) do
+      define_schema do |t|
+        t.string     :text
+        t.references :parent, foreign_key: true
+        t.references :label, foreign_key: true
+      end
+      define_model do
+        belongs_to :parent, inverse_of: :target
+        belongs_to :label, dependent: :destroy
+      end
+      define_viewmodel do
+        attributes :text
+        association :label
+      end
+    end
+  end
+end
+
+## Dummy Rails Controllers
+class DummyController
+  attr_reader :params, :status
+
+  def initialize(**params)
+    # in Rails 5, this will not be a hash, which weakens the value of the test.
+    @params = params.with_indifferent_access
+    @status = 200
+  end
+
+  def invoke(method)
+    begin
+      self.public_send(method)
+    rescue Exception => ex
+      handler = self.class.rescue_block(ex.class)
+      case handler
+      when nil
+        raise
+      when Symbol
+        self.send(handler, ex)
+      when Proc
+        self.instance_exec(ex, &handler)
+      end
+    end
+  end
+
+  def invoke_without_rescue(method)
+    self.public_send(method)
+  end
+
+  def render(status:, **options)
+    if options.has_key?(:json)
+      @response_body = options[:json]
+      @content_type = options[:content_type] || 'application/json'
+    elsif options.has_key?(:plain)
+      @response_body = options[:plain]
+      @content_type = options[:content_type] || 'text/plain'
+    end
+    @status = status unless status.nil?
+  end
+
+  def json_response
+    raise "Not a JSON response" unless @content_type == 'application/json'
+    @response_body
+  end
+
+  def hash_response
+    JSON.parse(json_response)
+  end
+
+  class << self
+    def inherited(subclass)
+      subclass.initialize_rescue_blocks
+    end
+
+    def initialize_rescue_blocks
+      @rescue_blocks = {}
+    end
+
+    def rescue_from(type, with:)
+      @rescue_blocks[type] = with
+    end
+
+    def rescue_block(type)
+      @rescue_blocks.to_a.reverse.detect { |btype, h| type <= btype }.try(&:last)
+    end
+
+    def etag(*)
+    end
+  end
+end
+
+# Provide dummy Rails env
+module Rails
+  def self.env
+    'production'
+  end
+end
+
+module ActionController
+  class Parameters
+  end
+end
+
+module CallbackTracing
+  attr_reader :callback_tracer
+  delegate :hook_trace, to: :callback_tracer
+
+  def new_deserialize_context(**args)
+    @callback_tracer ||= CallbackTracer.new
+    super(callbacks: [@callback_tracer])
+  end
+
+  def new_serialize_context(**args)
+    @callback_tracer ||= CallbackTracer.new
+    super(callbacks: [@callback_tracer])
+  end
+end
+
+module ControllerTestControllers
+  def before_all
+    super
+
+    Class.new(DummyController) do |c|
+      Object.const_set(:ParentController, self)
+      include ViewModel::ActiveRecord::Controller
+      include CallbackTracing
+      self.access_control = ViewModel::AccessControl::Open
+    end
+
+    Class.new(DummyController) do |c|
+      Object.const_set(:ChildController, self)
+      include ViewModel::ActiveRecord::Controller
+      include CallbackTracing
+      self.access_control = ViewModel::AccessControl::Open
+      nested_in :parent, as: :children
+    end
+
+    Class.new(DummyController) do |c|
+      Object.const_set(:LabelController, self)
+      include ViewModel::ActiveRecord::Controller
+      include CallbackTracing
+      self.access_control = ViewModel::AccessControl::Open
+      nested_in :parent, as: :label
+    end
+
+    Class.new(DummyController) do |c|
+      Object.const_set(:TargetController, self)
+      include ViewModel::ActiveRecord::Controller
+      include CallbackTracing
+      self.access_control = ViewModel::AccessControl::Open
+      nested_in :parent, as: :target
+    end
+  end
+
+  def after_all
+    [:ParentController, :ChildController, :LabelController, :TargetController].each do |name|
+      Object.send(:remove_const, name)
+    end
+    ActiveSupport::Dependencies::Reference.clear!
+    super
+  end
+end

data/test/helpers/match_enumerator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# From https://stackoverflow.com/a/41293357
+module MiniTest::Assertions
+  class MatchEnumerator
+    def initialize(expected, actual)
+      @expected = expected
+      @actual = actual
+    end
+
+    def match
+      return result, message
+    end
+
+    def result
+      return false unless @actual.respond_to? :to_a
+      @extra_items = difference_between_enumerators(@actual, @expected)
+      @missing_items = difference_between_enumerators(@expected, @actual)
+      @extra_items.empty? & @missing_items.empty?
+    end
+
+    def message
+      if @actual.respond_to? :to_a
+        message = "expected collection contained: #{safe_sort(@expected).inspect}\n"
+        message += "actual collection contained: #{safe_sort(@actual).inspect}\n"
+        message += "the missing elements were: #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty?
+        message += "the extra elements were: #{safe_sort(@extra_items).inspect}\n" unless @extra_items.empty?
+      else
+        message = "expected an array, actual collection was #{@actual.inspect}"
+      end
+
+      message
+    end
+
+    private
+
+    def safe_sort(array)
+      array.sort rescue array
+    end
+
+    def difference_between_enumerators(array_1, array_2)
+      difference = array_1.to_a.dup
+      array_2.to_a.each do |element|
+        if (index = difference.index(element))
+          difference.delete_at(index)
+        end
+      end
+      difference
+    end
+  end # MatchEnumerator
+
+  def assert_match_enumerator(expected, actual)
+    result, message = MatchEnumerator.new(expected, actual).match
+    assert result, message
+  end
+end # MiniTest::Assertions
+
+Enumerator.infect_an_assertion :assert_match_enumerator, :must_contain_exactly

data/test/helpers/query_logging.rb

@@ -0,0 +1,71 @@
+# Test mixin that allows queries executed in a block to be introspected.
+#
+# Code run within a `log_queries` block will collect data. Collected data is
+# inspected via `logged_queries` which returns everything, or via
+# `logged_named_queries`, which returns only valid payload names.
+#
+# Caveats: only supports single threaded testing.
+
+require 'active_support/subscriber'
+
+module QueryLogging
+
+  # ActiveRecord integration
+  class QueryLogger < ActiveSupport::Subscriber
+    @log              = false
+    @query_log        = []
+
+    attach_to :active_record
+
+    def self.clear!
+      @query_log = []
+    end
+
+    def self.with_query_log
+      clear!
+      @log = true
+      yield
+    ensure
+      @log = false
+    end
+
+    def self.log?
+      @log
+    end
+
+    def self.logged_events
+      @query_log
+    end
+
+    # All public methods are event handlers. The instance defines what to log,
+    # while the class defines how to handle it.
+
+    def sql(event)
+      if self.class.log?
+        self.class.logged_events << event
+      end
+    end
+  end
+
+  # Defensively clean up before every test.
+  def setup
+    super
+    QueryLogger.clear!
+  end
+
+  # Test helpers
+
+  def log_queries
+    QueryLogger.with_query_log { yield }
+  end
+
+  def logged_queries
+    QueryLogger.logged_events
+  end
+
+  def logged_load_queries
+    QueryLogger.logged_events
+      .map { |x| x.payload[:name] }
+      .select { |x| x && x =~ / Load$/ }
+  end
+end

data/test/helpers/test_access_control.rb

@@ -0,0 +1,56 @@
+require "iknow_view_models"
+
+
+class TestAccessControl < ViewModel::AccessControl
+  attr_accessor :editable_checks, :visible_checks
+
+  def initialize(can_view, can_edit, can_change)
+    super()
+    @can_edit          = can_edit
+    @can_view          = can_view
+    @can_change        = can_change
+    @editable_checks   = []
+    @visible_checks    = []
+    @valid_edit_checks = []
+  end
+
+  # Collect
+
+  def editable_check(traversal_env)
+    @editable_checks << traversal_env.view.to_reference
+    ViewModel::AccessControl::Result.new(@can_edit)
+  end
+
+  def valid_edit_check(traversal_env)
+    ref = traversal_env.view.to_reference
+    @valid_edit_checks << [ref, traversal_env.changes]
+    ViewModel::AccessControl::Result.new(@can_change)
+  end
+
+  def visible_check(traversal_env)
+    @visible_checks << traversal_env.view.to_reference
+    ViewModel::AccessControl::Result.new(@can_view)
+  end
+
+  # Query (also see attr_accessors)
+
+  def valid_edit_refs
+    @valid_edit_checks.map { |ref, _changes| ref }
+  end
+
+  def valid_edit_changes(ref)
+    all = all_valid_edit_changes(ref)
+    raise "Expected single change for ref '#{ref}'; found #{all}" unless all.size == 1
+    all.first
+  end
+
+  def all_valid_edit_changes(ref)
+    @valid_edit_checks
+      .select { | cref, _changes| cref == ref }
+      .map    { |_cref,  changes| changes }
+  end
+
+  def was_edited?(ref)
+    all_valid_edit_changes(ref).present?
+  end
+end