hyrax 5.0.0.rc2 → 5.0.0

data/spec/factories/permission_templates.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :permission_template, class: Hyrax::PermissionTemplate do
+    # Given that there is a one to one strong relation between permission_template and admin_set,
+    # with a unique index on the source_id, I don't want to have duplication in source_id
+    sequence(:source_id) { |n| format("%010d", n) }
+
+    trait :with_immediate_release do
+      release_period { Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY }
+    end
+
+    trait :with_delayed_release do
+      release_period { Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_6_MONTHS }
+    end
+
+    before(:create) do |permission_template, evaluator|
+      if evaluator.with_admin_set
+        source_id = permission_template.source_id
+        admin_set = SourceFinder.find_or_create_admin_set(source_id)
+        permission_template.source_id = admin_set.id
+      elsif evaluator.with_collection
+        source_id = permission_template.source_id
+        collection =
+          if source_id.present?
+            begin
+              Collection.find(source_id)
+            rescue ActiveFedora::ObjectNotFoundError
+              create(:collection, id: source_id)
+            end
+          else
+            create(:collection)
+          end
+        permission_template.source_id = collection.id
+      end
+    end
+
+    after(:create) do |permission_template, evaluator|
+      if evaluator.with_workflows
+        Hyrax::Workflow::WorkflowImporter.load_workflow_for(permission_template: permission_template)
+        Sipity::Workflow.activate!(permission_template: permission_template, workflow_id: permission_template.available_workflows.pick(:id))
+      end
+      if evaluator.with_active_workflow
+        workflow = create(:workflow, active: true, permission_template: permission_template)
+        create(:workflow_action, workflow: workflow) # Need to create a single action that can be taken
+      end
+      AccessHelper.create_access(permission_template, 'user', :manage, evaluator.manage_users) if evaluator.manage_users.present?
+      AccessHelper.create_access(permission_template, 'group', :manage, evaluator.manage_groups) if evaluator.manage_groups.present?
+      AccessHelper.create_access(permission_template, 'user', :deposit, evaluator.deposit_users) if evaluator.deposit_users.present?
+      AccessHelper.create_access(permission_template, 'group', :deposit, evaluator.deposit_groups) if evaluator.deposit_groups.present?
+      AccessHelper.create_access(permission_template, 'user', :view, evaluator.view_users) if evaluator.view_users.present?
+      AccessHelper.create_access(permission_template, 'group', :view, evaluator.view_groups) if evaluator.view_groups.present?
+    end
+
+    transient do
+      with_admin_set { false }
+      with_collection { false }
+      with_workflows { false }
+      with_active_workflow { false }
+      manage_users { nil }
+      manage_groups { nil }
+      deposit_users { nil }
+      deposit_groups { nil }
+      view_users { nil }
+      view_groups { nil }
+    end
+  end
+
+  class AccessHelper
+    def self.create_access(permission_template_id, agent_type, access, agent_ids)
+      agent_ids.each do |agent_id|
+        FactoryBot.create(:permission_template_access,
+                          access,
+                          permission_template: permission_template_id,
+                          agent_type: agent_type,
+                          agent_id: agent_id)
+      end
+    end
+  end
+
+  class SourceFinder
+    def self.find_or_create_admin_set(source_id)
+      Hyrax.config.use_valkyrie? ? find_or_create_admin_set_valkyrie(source_id) : find_or_create_admin_set_active_fedora(source_id)
+    end
+
+    def self.find_or_create_admin_set_active_fedora(source_id)
+      if source_id.present?
+        begin
+          AdminSet.find(source_id)
+        rescue ActiveFedora::ObjectNotFoundError
+          FactoryBot.create(:admin_set, id: source_id)
+        end
+      else
+        FactoryBot.create(:admin_set)
+      end
+    end
+
+    def self.find_or_create_admin_set_valkyrie(source_id)
+      if source_id.present?
+        begin
+          Hyrax.query_service.find_by(id: source_id)
+        rescue Valkyrie::Persistence::ObjectNotFoundError
+          # Creating an Administrative set with a pre-determined id will not work for all adapters
+          # so we're letting the adapter assign the id
+          FactoryBot.valkyrie_create(:hyrax_admin_set)
+        end
+      else
+        FactoryBot.valkyrie_create(:hyrax_admin_set)
+      end
+    end
+  end
+end

data/spec/factories/proxy_deposit_requests.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Read about factories at https://github.com/thoughtbot/factory_bot
+
+FactoryBot.define do
+  factory :proxy_deposit_request do
+  end
+end

data/spec/factories/single_use_links.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :single_use_link do
+    factory :show_link do
+      item_id { 'fs-id' }
+      path    { '/concerns/generic_work/1234' }
+    end
+
+    factory :download_link do
+      item_id { 'fs-id' }
+      path    { '/downloads/1234' }
+    end
+  end
+end

data/spec/factories/sipity_entities.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :sipity_entity, class: Sipity::Entity do
+    transient do
+      proxy_for { nil }
+    end
+
+    proxy_for_global_id { 'gid://internal/Mock/1' }
+    workflow { workflow_state.workflow }
+    workflow_state
+
+    after(:build) do |entity, evaluator|
+      entity.proxy_for_global_id = Hyrax::GlobalID(evaluator.proxy_for).to_s if
+        evaluator.proxy_for
+    end
+  end
+end

data/spec/factories/uploaded_files.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :uploaded_file, class: Hyrax::UploadedFile do
+    user
+    file { File.open(Hyrax::Engine.root.join('spec', 'fixtures', 'image.jp2').to_s) }
+
+    trait :audio do
+      file { File.open(Hyrax::Engine.root.join('spec', 'fixtures', 'sample_mpeg4.mp4').to_s) }
+    end
+  end
+end

data/spec/factories/users.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :user do
+    sequence(:email) { |n| "user#{n}@example.com" }
+    password { 'password' }
+
+    transient do
+      # Allow for custom groups when a user is instantiated.
+      # @example create(:user, groups: 'avacado')
+      groups { [] }
+    end
+
+    after(:build) do |user, evaluator|
+      User.group_service.add(user: user, groups: evaluator.groups)
+    end
+
+    factory :admin do
+      groups { ['admin'] }
+    end
+
+    factory :user_with_mail do
+      after(:create) do |user|
+        # Create examples of single file successes and failures
+        (1..10).each do |number|
+          file = MockFile.new(number.to_s, "Single File #{number}")
+          User.batch_user.send_message(user, 'File 1 could not be updated. You do not have sufficient privileges to edit it.', file.to_s, false)
+          User.batch_user.send_message(user, 'File 1 has been saved', file.to_s, false)
+        end
+
+        # Create examples of mulitple file successes and failures
+        files = []
+        (1..50).each do |number|
+          files << MockFile.new(number.to_s, "File #{number}")
+        end
+        User.batch_user.send_message(user, 'These files could not be updated. You do not have sufficient privileges to edit them.', 'Batch upload permission denied', false)
+        User.batch_user.send_message(user, 'These files have been saved', 'Batch upload complete', false)
+      end
+    end
+  end
+
+  trait :guest do
+    guest { true }
+  end
+end
+
+class MockFile
+  attr_accessor :to_s, :id
+  def initialize(id, string)
+    self.id = id
+    self.to_s = string
+  end
+end

data/spec/factories/workflow_actions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :workflow_action, class: Sipity::WorkflowAction do
+    workflow
+    name { 'submit' }
+  end
+end

data/spec/factories/workflow_states.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :workflow_state, class: Sipity::WorkflowState do
+    workflow
+    name { 'initial' }
+  end
+end

data/spec/factories/workflows.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :workflow, class: Sipity::Workflow do
+    sequence(:name) { |n| "generic_work-#{n}" }
+    permission_template
+  end
+end

data/spec/support/book_resource.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module Hyrax
+  module Test
+    ##
+    # A simple Hyrax::Resource with some metadata.
+    #
+    # Use this for testing valkyrie models generically, with Hyrax assumptions
+    # but no PCDM modelling behavior.
+    class BookResource < Hyrax::Resource
+      attribute :author,    Valkyrie::Types::String
+      attribute :created,   Valkyrie::Types::Date
+      attribute :isbn,      Valkyrie::Types::String
+      attribute :publisher, Valkyrie::Types::String
+      attribute :title,     Valkyrie::Types::String
+    end
+
+    ##
+    # A simple Hyrax::ChangeSet with one custom validation.
+    #
+    # Hyrax::Test::BookResource will use this based on naming convention by adding `ChangeSet`
+    # to the end of the resource class name.
+    class BookResourceChangeSet < Hyrax::ChangeSet
+      validates :isbn, presence: true
+    end
+
+    class Book < ActiveFedora::Base
+      property :author,    predicate: ::RDF::URI('http://example.com/ns/author')
+      property :created,   predicate: ::RDF::URI('http://example.com/ns/created')
+      property :isbn,      predicate: ::RDF::URI('http://example.com/ns/isbn')
+      property :publisher, predicate: ::RDF::URI('http://example.com/ns/publisher')
+      property :title,     predicate: ::RDF::URI("http://example.com/ns/title")
+    end
+  end
+end
+
+Wings::ModelRegistry.register(Hyrax::Test::BookResource, Hyrax::Test::Book) if defined?(Wings)

data/spec/support/can_can_overrides.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+##
+# This monkey-patch shim is for both active_fedora and valkyrie resources for tests
+# This shim handles the case where controllers are loaded with an ActiveFedora collection class
+# different than a test mocks Hyrax.config.collection_class.
+# This override checks the value in Hyrax.config and uses it when it is a known collection or admin set class.
+# This override also memoizes the resource_class to avoid multiple lookups.
+CanCan::ControllerResource.class_eval do
+  def resource_class
+    return @resource_class if @resource_class.present?
+    @resource_class = case @options[:class]
+                      when false then
+                        name.to_sym
+                      when nil then
+                        namespaced_name.to_s.camelize.constantize
+                      when String then
+                        @options[:class].constantize
+                      else
+                        @options[:class]
+                      end
+    @resource_class = dynamically_resolve_class(@resource_class)
+  end
+
+  private
+
+  def dynamically_resolve_class(resource_class)
+    if collection_class?(resource_class)
+      Hyrax.config.collection_class
+    elsif admin_set_class?(resource_class)
+      Hyrax.config.admin_set_class
+    else
+      resource_class
+    end
+  end
+
+  def collection_class?(model_class)
+    model_class == Hyrax::PcdmCollection || model_class < Hyrax::PcdmCollection || model_class == ::Collection || model_class < ::Collection
+  end
+
+  def admin_set_class?(model_class)
+    model_class == Hyrax::AdministrativeSet || model_class < Hyrax::AdministrativeSet || model_class == AdminSet || model_class < AdminSet
+  end
+end

data/spec/support/clean_solr.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+RSpec.configure do |config|
+  config.before(:each, clean_index: true) do
+    client = Valkyrie::IndexingAdapter.find(:solr_index).connection
+    client.delete_by_query("*:*", params: { softCommit: true })
+  end
+end

data/spec/support/controller_level_helpers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ControllerLevelHelpers
+  # This provides some common mock methods for view tests.
+  # These are normally provided by the controller.
+  module ControllerViewHelpers
+    def search_state
+      @search_state ||= CatalogController.search_state_class.new(params, blacklight_config, controller)
+    end
+
+    # This allows you to set the configuration
+    # @example: view.blacklight_config = Blacklight::Configuration.new
+    attr_writer :blacklight_config
+
+    def blacklight_config
+      @blacklight_config ||= CatalogController.blacklight_config
+    end
+
+    def blacklight_configuration_context
+      @blacklight_configuration_context ||= Blacklight::Configuration::Context.new(controller)
+    end
+  end
+
+  def initialize_controller_helpers(helper)
+    helper.extend ControllerViewHelpers
+  end
+end

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