hyrax 5.0.0.rc1 → 5.0.0.rc3

data/spec/support/factory_helpers.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+module Hyrax
+  module FactoryHelpers
+    module_function
+
+    FIELDS = { mime_type: 'text/plain',
+               content: 'content',
+               file_size: [],
+               format_label: [],
+               height: [],
+               width: [],
+               filename: [],
+               well_formed: [],
+               page_count: [],
+               file_title: [],
+               last_modified: [],
+               original_checksum: [],
+               alpha_channels: [],
+               digest: [],
+               duration: [],
+               sample_rate: [],
+               versions: [] }.freeze
+
+    def mock_file_factory(opts = {})
+      fields = FIELDS.each_with_object({}) do |(name, default), hsh|
+        hsh[name] = opts.fetch(name, default)
+      end
+
+      mock_model('MockOriginal', fields)
+    end
+
+    # as defined in Hyrax::FileMetadata
+    HYRAX_FILE_METADATA_FIELDS = { file_identifier: '',
+                                   alternate_ids: [],
+                                   file_set_id: '',
+                                   label: [''],
+                                   original_filename: '',
+                                   mime_type: 'text/plain',
+                                   type: [],
+                                   format_label: [],
+                                   size: [],
+                                   well_formed: [],
+                                   valid: [],
+                                   date_created: [],
+                                   fits_version: [],
+                                   exif_version: [],
+                                   checksum: [],
+                                   frame_rate: [],
+                                   bit_rate: [],
+                                   duration: [],
+                                   sample_rate: [],
+                                   height: [],
+                                   width: [],
+                                   bit_depth: [],
+                                   channels: [],
+                                   data_format: [],
+                                   offset: [],
+                                   file_title: [],
+                                   creator: [],
+                                   page_count: [],
+                                   language: [],
+                                   word_count: [],
+                                   character_count: [],
+                                   line_count: [],
+                                   character_set: [],
+                                   markup_basis: [],
+                                   markup_language: [],
+                                   paragraph_count: [],
+                                   table_count: [],
+                                   graphics_count: [],
+                                   byte_order: [],
+                                   compression: [],
+                                   color_space: [],
+                                   profile_name: [],
+                                   profile_version: [],
+                                   orientation: [],
+                                   color_map: [],
+                                   image_producer: [],
+                                   capture_device: [],
+                                   scanning_software: [],
+                                   gps_timestamp: [],
+                                   latitude: [],
+                                   longitude: [],
+                                   aspect_ratio: [] }.freeze
+
+    def mock_file_metadata_factory(opts = {})
+      fields = HYRAX_FILE_METADATA_FIELDS.each_with_object({}) do |(name, default), hsh|
+        hsh[name] = opts.fetch(name, default)
+      end
+
+      mock_model('MockFileMetadata', fields)
+    end
+  end
+end

data/spec/support/fakes/fake_actor.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+class FakeActor < Hyrax::Actors::AbstractActor
+  attr_accessor :created, :destroyed, :updated
+
+  def create(env)
+    self.created = env
+
+    true
+  end
+
+  def destroy(env)
+    self.destroyed = env
+
+    true
+  end
+
+  def update(env)
+    self.updated = env
+
+    true
+  end
+end

data/spec/support/fakes/fake_authority.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+class FakeAuthority
+  def initialize(map)
+    @map = map
+  end
+
+  def all
+    @map
+  end
+
+  def find(id)
+    @map.detect { |item| item[:id] == id }
+  end
+end

data/spec/support/fakes/fake_search_builder_scope.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+##
+# +Blacklight::SearchBuilder+ requires a 'scope' object, which its documentation
+# describes as "the scope where the filter methods reside in."
+#
+# Often (usually?) this is a Controller with:
+#   - +#blacklight_config+
+#   - +#current_ability+
+#   - +#current_user+
+#   - +#params+
+#   - +#repository+
+#   - +#search_state_class+
+#
+# This provides a fake scope with more control than a generic RSpec double.
+class FakeSearchBuilderScope
+  ##
+  # @!attribute [r] blacklight_config
+  #   @return [Blacklight::Configuration]
+  # @!attribute [r] current_ability
+  #   @return [::Ability]
+  # @!attribute [r] current_user
+  #   @return [::User, nil]
+  # @!attribute [r] params
+  #   @return [Hash]
+  # @!attribute [r] repository
+  #   @return [Blacklight::AbstractRepository]
+  # @!attribute [r] search_state_class
+  #   @return [Blacklight::SearchState, nil]
+  attr_reader :blacklight_config, :current_ability, :current_user, :params, :repository, :search_state_class
+
+  ##
+  # @param [Blacklight::Configuration] blacklight_config
+  # @param [::Ability, nil] current_ability
+  # @param [::User, nil] current_user
+  def initialize(blacklight_config: CatalogController.blacklight_config, current_ability: nil, current_user: nil, params: {}, search_state_class: nil)
+    @blacklight_config = blacklight_config
+    @current_user = current_user
+    @current_ability = current_ability || ::Ability.new(current_user)
+    @params = params
+    @repository = Blacklight::Solr::Repository.new(blacklight_config)
+    @search_state_class = search_state_class
+  end
+end

data/spec/support/fakes/indexing_adapter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+class FakeIndexingAdapter
+  attr_reader :deleted_resources, :saved_resources
+
+  def initialize
+    @deleted_resources = []
+    @saved_resources = []
+  end
+
+  def save(resource:)
+    @saved_resources << resource
+  end
+
+  def delete(resource:)
+    @deleted_resources << resource
+  end
+end

data/spec/support/fakes/test_hydra_group_service.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+##
+# A fake group service implementation for use in test suites as a drop-in
+# replacement for `RoleMapper` or the `hydra-role-management` gem, allowing
+# dynamic group assignment backed by in-memory data structures.
+#
+# @example setup the group service for an rspec test suite
+#   config.before(:suite) do
+#     ::User.group_service = TestHydraGroupService.new
+#   end
+#
+# @example adding a user to a group
+#   ::User.group_service.add(user: my_user, groups: ['a_group'])
+#
+# @example clearing the user -> group map
+#   ::User.group_service.clear
+#
+# @see Hydra::User.group_service
+class TestHydraGroupService
+  ##
+  # @param group_map [Hash{String, Array<String>}] map user keys to group names
+  def initialize(group_map: {})
+    @group_map = group_map
+  end
+
+  ##
+  # @param user [::User]
+  # @param groups [Array<String>, String]
+  #
+  # @return [void]
+  def add(user:, groups:)
+    @group_map[user.user_key] = fetch_groups(user: user) + Array(groups)
+  end
+
+  ##
+  # @return [void]
+  def clear
+    @group_map = {}
+  end
+
+  ##
+  # @param user [::User]
+  #
+  # @return [Array<String>]
+  def fetch_groups(user:)
+    @group_map.fetch(user.user_key) { [] }
+  end
+
+  ##
+  # @return [Array<String>] a list of all known group names
+  def role_names
+    @group_map.values.flatten.uniq
+  end
+end

data/spec/support/features/batch_edit_actions.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+def batch_edit_fields
+  # skipping based_near because it's a select2 field, which is hard to test via capybara
+  [
+    "creator", "contributor", "description", "keyword", "publisher", "date_created",
+    "subject", "language", "identifier", "related_url"
+  ]
+end
+
+def fill_in_batch_edit_fields_and_verify!
+  batch_edit_fields.each do |field_id|
+    within "#form_#{field_id}" do
+      batch_edit_expand(field_id)
+      page.find("##{expected_element_text}_#{field_id}") # Ensuring that the element is on the page before we fill it
+      fill_in "#{expected_element_text}_#{field_id}", with: "NEW #{field_id}"
+
+      find("##{field_id}_save").click
+
+      ajax_wait(15)
+      # This was `expect(page).to have_content 'Changes Saved'`, however in debugging,
+      # the `have_content` check was ignoring the `within` scoping and finding
+      # "Changes Saved" for other field areas
+      find('.status', text: 'Changes Saved')
+    end
+  end
+end
+
+def batch_edit_expand(field)
+  find("#expand_link_#{field}").click
+  yield if block_given?
+end
+
+def ajax_wait(s)
+  Timeout.timeout(s) do
+    loop until page.evaluate_script("jQuery.active").zero?
+  end
+end

data/spec/support/features/session_helpers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+# spec/support/features/session_helpers.rb
+module Features
+  module SessionHelpers
+    def sign_in(who = :user)
+      logout
+      user = who.is_a?(User) ? who : build(:user).tap(&:save!)
+      visit new_user_session_path
+      fill_in 'Email', with: user.email
+      fill_in 'Password', with: user.password
+      click_button 'Log in'
+      expect(page).not_to have_text 'Invalid email or password.'
+    end
+  end
+end

data/spec/support/features/workflow.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+def ensure_deposit_available_for(user)
+  template = create(:permission_template, with_admin_set: true, with_workflows: true)
+  # Grant the user access to deposit into an admin set.
+  create(:permission_template_access,
+         :deposit,
+         permission_template: template,
+         agent_type: 'user',
+         agent_id: user.user_key)
+end

data/spec/support/features.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+# spec/support/features.rb
+require File.expand_path('../features/session_helpers', __FILE__)
+require File.expand_path('../features/workflow', __FILE__)
+require File.expand_path('../features/batch_edit_actions', __FILE__)
+require File.expand_path('../selectors', __FILE__)
+require File.expand_path('../statistic_helper', __FILE__)
+
+RSpec.configure do |config|
+  config.include Features::SessionHelpers, type: :feature
+end

data/spec/support/form_with_validations.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Hyrax
+  module Test
+    class FormWithValidations < Hyrax::Forms::ResourceForm
+      property :title
+
+      validates :title, presence: true
+
+      # Added to comply with Hyrax::Forms::FailedSubmissionFormWrapper
+      def permitted_params
+        { title: [] }
+      end
+    end
+  end
+end

data/spec/support/input_support.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module InputSupport
+  extend ActiveSupport::Concern
+
+  include RSpec::Rails::HelperExampleGroup
+
+  def input_for(object, attribute_name, options = {})
+    helper.simple_form_for object, url: '' do |f|
+      f.input attribute_name, options
+    end
+  end
+end

data/spec/support/logging_formatter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+class LoggingFormatter < RSpec::Core::Formatters::ProgressFormatter
+  RSpec::Core::Formatters.register self, :example_started, :example_passed, :dump_profile
+  def initialize(output)
+    @profile = []
+    reset!
+    ActiveSupport::Notifications.subscribe("http.ldp", method(:record_request))
+    super
+  end
+
+  def record_request(*_unused, data)
+    @request_count += 1
+    @request_count_by_name[data[:name]] += 1
+  end
+
+  def example_passed(passed)
+    super
+    @profile << { description: passed.example.full_description,
+                  count: @request_count,
+                  location: passed.example.location,
+                  count_by_name: @request_count_by_name }
+  end
+
+  def example_started(_passed)
+    reset!
+  end
+
+  def reset!
+    @request_count = 0
+    @request_count_by_name = { 'HEAD' => 0,
+                               'GET' => 0,
+                               'POST' => 0,
+                               'DELETE' => 0,
+                               'PUT' => 0,
+                               'PATCH' => 0 }
+  end
+
+  def dump_profile(profile)
+    dump_most_ldp_exampes(profile)
+    output.puts ""
+    dump_slowest_examples(profile)
+  end
+
+  private
+
+  def dump_most_ldp_exampes(_prof)
+    output.puts "Examples with the most LDP requests"
+    top = @profile.sort_by { |hash| hash[:count] }.last(10)
+    top.each do |hash|
+      result = hash[:count_by_name].select { |_, v| v.positive? }
+      next if result.empty?
+      output.puts "  #{hash[:description]}"
+      output.puts "    #{hash[:location]}"
+      output.puts "    Total LDP: #{hash[:count]} #{result}"
+    end
+  end
+
+  def dump_slowest_examples(profile)
+    output.puts "Slowest examples"
+    profile.slowest_examples.each do |slowest_example|
+      output.puts "  #{slowest_example.full_description}"
+      output.puts "    #{slowest_example.location}"
+      output.puts "    #{slowest_example.execution_result.run_time} seconds"
+    end
+  end
+end

data/spec/support/matchers/api_responses.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# RSpec matchers for API default JSON responses.
+# Creates a matcher like respond_forbidden or respond_not_found corresponding to each of the Api::V1.default_responses
+# Accepts optional overrides to the expected response body.
+# @example Override the description expected in the JSON body of a :forbidden response
+#   expect(response).to respond_forbidden(description:"You can't create for that identity")
+::Hyrax::API.default_responses.each_pair do |response_type, default_response_body|
+  RSpec::Matchers.define "respond_#{response_type}".to_sym do |expectation_options|
+    match do |response|
+      @expected_response_body = expectation_options.nil? ? default_response_body : default_response_body.merge(expectation_options)
+      expect(response.body).not_to be_empty
+      json = JSON.parse(response.body)
+      expect(response.code).to eq(@expected_response_body[:code].to_s)
+      @expected_response_body.each_pair do |key, value|
+        expect(json[key.to_s]).to eq(value.as_json)
+      end
+    end
+
+    failure_message do |actual|
+      "expected #{default_response_body[:code]} status code. Got #{actual.code} status code.\n" \
+      "expected an Authentication Required response like this:\n" \
+      " #{@expected_response_body.to_json} \ngot\n #{actual.body}\n" \
+      "To override expectations about the response body, provide a Hash of overrides in " \
+      "your call to :respond_#{response_type} "
+    end
+  end
+end

data/spec/support/matchers/collection_type_property_matchers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+RSpec::Matchers.define :require_membership do
+  match do |actual|
+    actual&.require_membership?
+  end
+end
+
+RSpec::Matchers.define :allow_multiple_membership do
+  match do |actual|
+    actual&.allow_multiple_membership?
+  end
+end
+
+RSpec::Matchers.define :assign_visibility do
+  match do |actual|
+    actual&.assigns_visibility?
+  end
+end
+
+RSpec::Matchers.define :assign_workflow do
+  match do |actual|
+    actual&.assigns_workflow?
+  end
+end
+
+RSpec::Matchers.define :have_collections do
+  match do |actual|
+    actual&.collections&.any?
+  end
+end

data/spec/support/matchers/embargo.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec::Matchers.define :be_an_embargo_matching do |embargo_args|
+  match do |embargo|
+    (embargo.visibility_after_embargo == embargo_args[:after]) &&
+      (embargo.visibility_during_embargo == embargo_args[:during]) &&
+      embargo.embargo_release_date.to_s.start_with?(embargo_args[:release_date][0..9])
+  end
+end

data/spec/support/matchers/lease.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec::Matchers.define :be_a_lease_matching do |lease_args|
+  match do |lease|
+    (lease.visibility_after_lease == lease_args[:after]) &&
+      (lease.visibility_during_lease == lease_args[:during]) &&
+      lease.lease_expiration_date.to_s.start_with?(lease_args[:release_date][0..9])
+  end
+end

data/spec/support/matchers/match_valkyrie_ids_with_af_ids.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Hyrax::Matchers
+  class MatchValkyrieIdsWithActiveFedoraIds < RSpec::Matchers::BuiltIn::ContainExactly
+    def match_when_sorted?
+      values_match?(safe_sort(expected), safe_sort(actual.map(&:id)))
+    end
+  end
+
+  def match_valkyrie_ids_with_active_fedora_ids(expected_fedora_ids)
+    MatchValkyrieIdsWithActiveFedoraIds.new(expected_fedora_ids)
+  end
+end

data/spec/support/matchers/pcdm_matchers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+RSpec::Matchers.define :have_file_set_members do |*expected_file_sets|
+  match do |actual_work|
+    actual_file_sets = Hyrax.custom_queries.find_child_file_sets(resource: actual_work)
+
+    expect(actual_file_sets).to contain_exactly(*expected_file_sets)
+  end
+end
+
+RSpec::Matchers.define :have_attached_files do |*expected_files|
+  match do |actual_file_set|
+    @actual_files = Hyrax.custom_queries.find_files(file_set: actual_file_set)
+
+    (expected_files.empty? && @actual_files.any?) ||
+      values_match?(expected_files, @actual_files)
+  end
+
+  failure_message_for_should do |actual_file_set|
+    if expected_files.empty?
+      "Expected #{actual_file_set} to have at least one file.\n" \
+      "Found #{@actual_files}."
+    else
+      "Expected #{actual_file_set} to have files: #{expected_files}\n" \
+      "Found #{@actual_files}."
+    end
+  end
+end
+
+RSpec::Matchers.define :be_a_resource_with_permissions do |*expected_permissions|
+  match do |actual_resource|
+    expect(Hyrax::AccessControlList.new(resource: actual_resource).permissions)
+      .to include(*expected_permissions)
+  end
+end

data/spec/support/matchers/permission.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+RSpec::Matchers.define :grant_permission do |acl_type|
+  match do |permission|
+    access_match = permission.access == acl_type.to_s
+
+    agent_match =
+      if user_id
+        permission.type == 'person' &&
+          permission.agent.first.id.include?(user_id.to_s)
+      elsif group_id
+        permission.type == 'group' &&
+          permission.agent.first.id.include?(group_id.to_s)
+      else
+        true
+      end
+
+    target_match =
+      if access_to_id
+        permission.access_to_id == access_to_id.to_s
+      else
+        true
+      end
+
+    return access_match && agent_match && target_match
+  end
+
+  chain :on,       :access_to_id
+  chain :to_user,  :user_id
+  chain :to_group, :group_id
+end

data/spec/support/matchers/response_matchers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+RSpec::Matchers.define :fail_redirect_and_flash do |path, flash_message|
+  match do |response|
+    expect(response.status).to eq 302
+    expect(response).to redirect_to(path)
+    expect(flash[:alert]).to eq flash_message
+  end
+end

data/spec/support/optional_example.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module OptionalExample
+  RSpec.configure do |config|
+    config.after do |example|
+      if example.metadata[:optional] && (RSpec::Core::Pending::PendingExampleFixedError === example.display_exception) # rubocop:disable Style/CaseEquality
+        ex = example.display_exception
+        example.display_exception = nil
+        example.execution_result.pending_exception = ex
+      end
+    end
+  end
+
+  def optional(message)
+    RSpec.current_example.metadata[:optional] = true
+    pending(message)
+  end
+end

data/spec/support/rake.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require 'rake'
+
+module RakeHelper
+  def load_rake_environment(files)
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    Rake::Task.define_task(:environment)
+    files.each { |file| load file }
+  end
+
+  def run_task(task, arg = nil)
+    capture_stdout_stderr do
+      @rake[task].invoke(arg)
+    end
+  end
+
+  # saves original $stdout in variable
+  # set $stdout as local instance of StringIO
+  # yields to code execution
+  # returns the local instance of StringIO
+  # resets $stdout to original value
+  def capture_stdout_stderr
+    out = StringIO.new
+    err = StringIO.new
+    $stdout = out
+    $stderr = err
+    begin
+      yield
+    rescue SystemExit => e
+      puts "error = #{e.inspect}"
+    end
+    "Output: #{out.string}\n Errors:#{err.string}"
+  ensure
+    $stdout = STDOUT
+    $stdout = STDERR
+  end
+
+  RSpec.configure do |config|
+    config.include RakeHelper
+  end
+end