hyrax 2.6.0 → 2.7.0

data/spec/controllers/hyrax/workflow_actions_controller_spec.rb

@@ -1,54 +0,0 @@
-RSpec.describe Hyrax::WorkflowActionsController, type: :controller do
-  let(:user) { create(:user) }
-  let(:generic_work) { stub_model(GenericWork, id: '123') }
-  let(:form) { instance_double(Hyrax::Forms::WorkflowActionForm) }
-
-  routes { Rails.application.routes }
-
-  before do
-    allow(ActiveFedora::Base).to receive(:find).with(generic_work.to_param).and_return(generic_work)
-    allow(generic_work).to receive(:persisted?).and_return(true)
-    allow(Hyrax::Forms::WorkflowActionForm).to receive(:new).and_return(form)
-  end
-
-  describe '#update' do
-    it 'will redirect to login path if user not authenticated' do
-      put :update, params: { id: generic_work.to_param, workflow_action: { name: 'advance', comment: '' } }
-      expect(response).to redirect_to(main_app.user_session_path)
-    end
-
-    it 'will render :unauthorized when action is not valid for the given user' do
-      expect(form).to receive(:save).and_return(false)
-      sign_in(user)
-
-      put :update, params: { id: generic_work.to_param, workflow_action: { name: 'advance', comment: '' } }
-      expect(response).to be_unauthorized
-    end
-
-    it 'will redirect when the form is successfully save' do
-      expect(form).to receive(:save).and_return(true)
-      sign_in(user)
-
-      put :update, params: { id: generic_work.to_param, workflow_action: { name: 'advance', comment: '' } }
-      expect(response).to redirect_to(main_app.hyrax_generic_work_path(generic_work, locale: 'en'))
-    end
-
-    context 'when responding to json' do
-      it 'will render :ok when the form is successfully saved' do
-        expect(form).to receive(:save).and_return(true)
-        sign_in(user)
-
-        put :update, params: { id: generic_work.to_param, workflow_action: { name: 'advance', comment: '' } }, format: :json
-        expect(response.status).to eq 200
-      end
-
-      it 'will render :unprocessable_entity when the form fails to save' do
-        expect(form).to receive(:save).and_return(false)
-        sign_in(user)
-
-        put :update, params: { id: generic_work.to_param, workflow_action: { name: 'advance', comment: '' } }, format: :json
-        expect(response.status).to eq 422
-      end
-    end
-  end
-end

data/spec/conversions/power_converters/polymorphic_type_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-RSpec.describe 'PowerConverter' do
-  describe '#convert_to_polymorphic_type' do
-    it 'will convert an object that responds to #to_polymorphic_type' do
-      object = double(to_polymorphic_type: :symbol)
-      expect(PowerConverter.convert_to_polymorphic_type(object)).to eq(:symbol)
-    end
-    it 'will convert an ActiveRecord::Base object' do
-      user = build(:user)
-      expect(PowerConverter.convert_to_polymorphic_type(user)).to eq(user.class)
-    end
-    it 'will convert an object that responds to #base_class' do
-      object = double(base_class: :symbol)
-      expect(PowerConverter.convert_to_polymorphic_type(object)).to eq(:symbol)
-    end
-
-    it 'will fail to convert strings' do
-      expect { PowerConverter.convert_to_polymorphic_type('hello') }.to raise_error(PowerConverter::ConversionError)
-    end
-  end
-end

data/spec/conversions/power_converters/sipity_action_name_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-RSpec.describe 'PowerConverter' do
-  context '#convert_to_sipity_action_name' do
-    [
-      [:show, 'show'],
-      [:show?, 'show'],
-      [:new?, 'new'],
-      [:new, 'new'],
-      [:edit?, 'edit'],
-      [:edit, 'edit'],
-      [:submit, 'submit'],
-      [:submit?, 'submit'],
-      [:attach, 'attach'],
-      [Sipity::WorkflowAction.new(name: 'hello'), 'hello']
-    ].each_with_index do |(original, expected), index|
-      it "will convert #{original.inspect} to #{expected.inspect} (scenario ##{index})" do
-        expect(PowerConverter.convert_to_sipity_action_name(original)).to eq(expected)
-      end
-    end
-
-    it 'will raise an exception if it is not processible' do
-      object = double('Bad Wolf')
-      expect { PowerConverter.convert_to_sipity_action_name(object) }.to raise_error(PowerConverter::ConversionError)
-    end
-
-    it 'will leverage a short-circuit #to_processing_action_name' do
-      object = double(to_sipity_action_name: 'bob')
-      expect(PowerConverter.convert_to_sipity_action_name(object)).to eq('bob')
-    end
-  end
-end

data/spec/conversions/power_converters/sipity_action_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-RSpec.describe 'PowerConverter' do
-  let(:workflow_id) { 1 }
-  let(:action) { Sipity::WorkflowAction.new(id: 4, name: 'show', workflow_id: workflow_id) }
-
-  context "with workflow_id and action's workflow_id matching" do
-    it 'will return the object if it is a Sipity::WorkflowAction' do
-      expect(PowerConverter.convert(action, to: :sipity_action, scope: workflow_id)).to eq(action)
-    end
-
-    it 'will return the object if it responds to #to_sipity_action' do
-      object = double(to_sipity_action: action)
-      expect(PowerConverter.convert(object, to: :sipity_action, scope: workflow_id)).to eq(action)
-    end
-
-    it 'will raise an error if it cannot convert the object' do
-      object = double
-      expect { PowerConverter.convert(object, to: :sipity_action, scope: workflow_id) }
-        .to raise_error(PowerConverter::ConversionError)
-    end
-
-    it 'will use a found action based on the given string and workflow_id' do
-      expect(Sipity::WorkflowAction).to receive(:find_by).and_return(action)
-      expect(PowerConverter.convert(action.name, to: :sipity_action, scope: workflow_id)).to eq(action)
-    end
-
-    context "when the WorkflowAction can not be found" do
-      it 'will raise an error' do
-        expect(Sipity::WorkflowAction).to receive(:find_by).and_return(nil)
-        expect { PowerConverter.convert(action.name, to: :sipity_action, scope: workflow_id) }
-          .to raise_error(PowerConverter::ConversionError)
-      end
-    end
-  end
-
-  context "with mismatching workflow_id and action's workflow_id" do
-    it "will fail an error if the scope's workflow_id is different than the actions" do
-      expect { PowerConverter.convert(action, to: :sipity_action, scope: workflow_id + 1) }
-        .to raise_error(PowerConverter::ConversionError)
-    end
-  end
-end

data/spec/conversions/power_converters/sipity_agent_spec.rb

@@ -1,20 +0,0 @@
-require "spec_helper"
-
-RSpec.describe 'PowerConverter' do
-  context '#convert_to_sipity_agent' do
-    it 'will convert a Sipity::Agent' do
-      object = Sipity::Agent.new
-      expect(PowerConverter.convert_to_sipity_agent(object)).to eq(object)
-    end
-
-    it 'will convert an object that responds to #to_sipity_agent' do
-      object = double(to_sipity_agent: :a_sipity_agent)
-      expect(PowerConverter.convert_to_sipity_agent(object)).to eq(:a_sipity_agent)
-    end
-
-    it 'will raise an exception if it cannot convert the given object' do
-      object = double
-      expect { PowerConverter.convert_to_sipity_agent(object) }.to raise_error(PowerConverter::ConversionError)
-    end
-  end
-end

data/spec/conversions/power_converters/sipity_entity_spec.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-RSpec.describe 'PowerConverter' do
-  context '#convert_to_sipity_entity' do
-    subject { PowerConverter.convert_to_sipity_entity(object) }
-
-    context "with a Sipity::Entity" do
-      let(:object) { Sipity::Entity.new }
-
-      it { is_expected.to eq object }
-    end
-
-    context "with a Sipity::Comment" do
-      let(:object) { Sipity::Comment.new(entity: entity) }
-      let(:entity) { Sipity::Entity.new }
-
-      it { is_expected.to eq entity }
-    end
-
-    context "with a SolrDocument" do
-      subject { PowerConverter.convert(object, to: :sipity_entity) }
-
-      let(:object) { SolrDocument.new(id: '9999', has_model_ssim: ["GenericWork"]) }
-      let(:workflow_state) { create(:workflow_state) }
-      let!(:entity) do
-        Sipity::Entity.create(proxy_for_global_id: 'gid://internal/GenericWork/9999',
-                              workflow_state: workflow_state,
-                              workflow: workflow_state.workflow)
-      end
-
-      it { is_expected.to eq entity }
-    end
-
-    context 'a Models::Work (because it will be processed)' do
-      # This is poking knowledge over into the inner workings of Models::Work
-      # but is a reasonable place to understand this.
-      it 'will raise an exception if one has not been assigned' do
-        object = build(:generic_work)
-        expect { PowerConverter.convert_to_sipity_entity(object) }.to raise_error RuntimeError, "Can't create an entity until the model has been persisted"
-      end
-    end
-
-    it 'will return the to_processing_entity if the object responds to the processing entity' do
-      object = double(to_sipity_entity: :processing_entity)
-      expect(PowerConverter.convert_to_sipity_entity(object)).to eq(:processing_entity)
-    end
-
-    it 'will raise an error if it cannot convert' do
-      object = double
-      expect { PowerConverter.convert_to_sipity_entity(object) }.to raise_error PowerConverter::ConversionError
-    end
-  end
-end

data/spec/conversions/power_converters/sipity_role_spec.rb

@@ -1,31 +0,0 @@
-RSpec.describe 'PowerConverter' do
-  context 'role' do
-    it "converts Sipity::Role" do
-      object = Sipity::Role.new
-      expect(PowerConverter.convert(object, to: :sipity_role)).to eq(object)
-    end
-
-    it "converts a #to_sipity_role object" do
-      object = double(to_sipity_role: Sipity::Role.new)
-      expect(PowerConverter.convert(object, to: :sipity_role)).to eq(object.to_sipity_role)
-    end
-
-    it "converts a string to a Sipity::Role if there exists a Sipity::Role with a name equal to the string" do
-      Sipity::Role.create!(name: 'hello')
-      expect(PowerConverter.convert('hello', to: :sipity_role)).to be_a(Sipity::Role)
-    end
-
-    it "creates a new role if given a string and no Sipity::Role exists with that name" do
-      expect { PowerConverter.convert('hello', to: :sipity_role) }.to change { Sipity::Role.count }.by(1)
-    end
-
-    it "converts a base object with composed attributes delegator" do
-      base_object = Sipity::Role.new
-      expect(PowerConverter.convert(base_object, to: :sipity_role)).to eq(base_object)
-    end
-
-    it 'does not convert an arbitrary object' do
-      expect { PowerConverter.convert(double, to: :sipity_role) }.to raise_error(PowerConverter::ConversionError)
-    end
-  end
-end

data/spec/conversions/power_converters/sipity_workflow_id_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-RSpec.describe 'PowerConverter' do
-  [
-    [Sipity::Workflow.new(id: 12), 12],
-    ["11", 11],
-    [2, 2],
-    [Sipity::Entity.new(workflow_id: 37), 37]
-  ].each_with_index do |(to_convert, expected), index|
-    it "will convert #{to_convert.inspect} to #{expected} (Scenario ##{index}" do
-      expect(PowerConverter.convert_to_sipity_workflow_id(to_convert)).to eq(expected)
-    end
-  end
-
-  it "will convert a processing entity to a strategy" do
-    to_convert = double(to_sipity_entity: double(workflow_id: 1))
-    expect(PowerConverter.convert_to_sipity_workflow_id(to_convert)).to eq(1)
-  end
-
-  it "will fail if the to_processing_entity fails a processing entity to a strategy" do
-    to_convert = double(to_processing_entity: double)
-    expect { PowerConverter.convert_to_sipity_workflow_id(to_convert) }.to raise_error(PowerConverter::ConversionError)
-  end
-
-  it 'will raise an exception if it cannot convert' do
-    expect { PowerConverter.convert_to_sipity_workflow_id(double) }.to raise_error(PowerConverter::ConversionError)
-  end
-end

data/spec/conversions/power_converters/sipity_workflow_state_spec.rb

@@ -1,20 +0,0 @@
-RSpec.describe 'PowerConverter' do
-  context 'sipity_workflow_state' do
-    let(:workflow_state) { Sipity::WorkflowState.new(id: 1, name: 'hello') }
-    let(:workflow) { create(:workflow) }
-
-    it 'will convert a Sipity::WorkflowState' do
-      expect(PowerConverter.convert(workflow_state, to: :sipity_workflow_state)).to eq(workflow_state)
-    end
-
-    it 'will convert a string based on scope' do
-      create(:workflow_state, workflow_id: workflow.id, name: 'hello')
-      PowerConverter.convert('hello', scope: workflow, to: :sipity_workflow_state)
-    end
-
-    it 'will attempt convert a string based on scope' do
-      expect { PowerConverter.convert('missing', scope: workflow, to: :sipity_workflow_state) }
-        .to raise_error(PowerConverter::ConversionError)
-    end
-  end
-end

data/spec/factories/admin_sets.rb

@@ -1,25 +0,0 @@
-FactoryBot.define do
-  factory :admin_set do
-    sequence(:title) { |n| ["Title #{n}"] }
-
-    # Given the relationship between permission template and admin set, when
-    # an admin set is created via a factory, I believe it is appropriate to go ahead and
-    # create the corresponding permission template
-    #
-    # This way, we can go ahead
-    after(:create) do |admin_set, evaluator|
-      if evaluator.with_permission_template
-        attributes = { source_id: admin_set.id }
-        attributes = evaluator.with_permission_template.merge(attributes) if evaluator.with_permission_template.respond_to?(:merge)
-        # There is a unique constraint on permission_templates.source_id; I don't want to
-        # create a permission template if one already exists for this admin_set
-        create(:permission_template, attributes) unless Hyrax::PermissionTemplate.find_by(source_id: admin_set.id)
-      end
-    end
-
-    transient do
-      # false, true, or Hash with keys for permission_template
-      with_permission_template { false }
-    end
-  end
-end

data/spec/factories/admin_sets_lw.rb

@@ -1,215 +0,0 @@
-FactoryBot.define do
-  # Tests that create a Fedora Object are very slow.  This factory lets you control which parts of the object ecosystem
-  # get built.
-  #
-  # PREFERRED: Use build whenever possible.  You can control the creation of the permission template and solr document
-  #            by passing parameters to the build(:admin_set_lw) method.  That way you can build only the parts needed
-  #            for a specific test.
-  #
-  # AVOID: Do not use create unless absolutely necessary.  It will create everything including the Fedora object.
-  #
-  # @example Simple build of an admin set with no additional parts created.  Lightest weight.
-  #          NOTE: A user is automatically created as the owner of the admin set.
-  #   let(:adminset) { build(:adminset_lw) }
-  #
-  # @example Simple build of an admin set with no additional parts created.  User is the owner of the admin set.  Lightest weight.
-  #   let(:adminset) { build(:adminset_lw, user:) }
-  #
-  # @example Simple build of an admin set with only solr-document.  Owner is given edit-access in solr-document. Light weight.
-  #   let(:adminset) { build(:adminset_lw, with_solr_document: true) }
-  #
-  # @example Simple build of an admin set with only a permission template created.  Owner is set as a manager.  Light weight.
-  #   let(:adminset) { build(:adminset_lw, with_permission_template: true) }
-  #
-  # @example Build an admin set with only a permission template created.  Permissions are set based on
-  #          attributes set for `with_permission_template`.  Middle weight.
-  #   # permissions passed thru `with_permission_template` can be any of the following in any combination
-  #   let(:permissions) { { manage_users: [user.user_key],  # multiple users can be listed
-  #                         deposit_users: [user.user_key],
-  #                         view_users: [user.user_key],
-  #                         manage_groups: [group_name],    # multiple groups can be listed
-  #                         deposit_groups: [group_name],
-  #                         view_groups: [group_name],  } }
-  #   let(:adminset) { build(:adminset_lw, user: , with_permission_template: permissions) }
-  #
-  # @example Build an admin set with permission template and solr-document created.  Permissions are set based on
-  #          attributes set for `with_permission_template`.  Solr-document includes read/edit access defined based
-  #          on attributes passed thru `with_permission_template`.  Middle weight.
-  #   # permissions passed thru `with_permission_template` can be any of the following in any combination
-  #   let(:permissions) { { manage_users: [user.user_key],  # multiple users can be listed
-  #                         deposit_users: [user.user_key],
-  #                         view_users: [user.user_key],
-  #                         manage_groups: [group_name],    # multiple groups can be listed
-  #                         deposit_groups: [group_name],
-  #                         view_groups: [group_name],  } }
-  #   let(:adminset) { build(:adminset_lw, user: , with_permission_template: permissions, with_solr_document: true) }
-  #
-  # @example Create an admin set with everything.  Extreme heavy weight.  This is very slow and should be avoided.
-  #          NOTE: Everything gets created.
-  #          NOTE: Build options effect created admin sets as follows...
-  #                 * `with_permission_template` can specify user/group permissions.  A permission template is always created.
-  #                 * `with_solr_document` is ignored.  A solr document is always created.
-  #   let(:adminset) { create(:adminset_lw) }
-  #
-  # @example Build the default admin set with permission template, solr doc, and default adminset's metadata.
-  #   let(:default_adminset) { build(:default_adminset) }
-
-  factory :adminset_lw, class: AdminSet do
-    transient do
-      user { create(:user) }
-
-      with_permission_template { false }
-      with_solr_document { false }
-    end
-    sequence(:title) { |n| ["Collection Title #{n}"] }
-
-    after(:build) do |adminset, evaluator|
-      adminset.creator = [evaluator.user.user_key]
-
-      AdminSetFactoryHelper.process_with_permission_template(adminset, evaluator)
-      AdminSetFactoryHelper.process_with_solr_document(adminset, evaluator)
-    end
-
-    before(:create) do |adminset, evaluator|
-      # force create a permission template if it doesn't exist for the newly created admin set
-      AdminSetFactoryHelper.process_with_permission_template(adminset, evaluator, true) unless evaluator.with_permission_template
-    end
-
-    after(:create) do |adminset, _evaluator|
-      adminset.reset_access_controls!
-    end
-
-    factory :default_adminset, class: AdminSet do
-      transient do
-        with_permission_template do
-          {
-            deposit_groups: [::Ability.registered_group_name],
-            manage_groups: [::Ability.admin_group_name]
-          }
-        end
-        with_solr_document { true }
-      end
-      id { AdminSet::DEFAULT_ID }
-      title { AdminSet::DEFAULT_TITLE }
-    end
-  end
-
-  factory :no_solr_grants_adminset, class: AdminSet do
-    # Builds a pre-Hyrax 2.1.0 adminset without edit/view grants on the admin set.
-    # Do not use with create because the save will cause the solr grants to be created.
-    transient do
-      user { create(:user) }
-      with_permission_template { true }
-      with_solr_document { true }
-    end
-
-    sequence(:title) { |n| ["No Solr Grant Admin Set Title #{n}"] }
-
-    after(:build) do |adminset, evaluator|
-      adminset.creator = [evaluator.user.user_key]
-      AdminSetFactoryHelper.process_with_permission_template(adminset, evaluator, true)
-      AdminSetFactoryHelper.process_with_solr_document(adminset, evaluator, true)
-    end
-  end
-
-  class AdminSetFactoryHelper
-    # @returns array of user keys
-    def self.permission_from_template(permission_template_attributes, permission_key)
-      permissions = []
-      return permissions if permission_template_attributes.blank?
-      return permissions unless permission_template_attributes.is_a? Hash
-      return permissions unless permission_template_attributes.key?(permission_key)
-      permission_template_attributes[permission_key]
-    end
-    private_class_method :permission_from_template
-
-    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
-    # @parem [String] creator_user is the user who created the new admin set
-    # @param [Boolean] include_creator, when true, adds the creator_user as a manager
-    # @returns array of user keys
-    def self.user_managers(permission_template_attributes, creator_user)
-      managers = permission_from_template(permission_template_attributes, :manage_users)
-      managers << creator_user
-      managers.uniq
-    end
-
-    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
-    # @returns array of user keys
-    def self.group_managers(permission_template_attributes)
-      permission_from_template(permission_template_attributes, :manage_groups).uniq
-    end
-
-    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
-    # @returns array of user keys
-    def self.user_depositors(permission_template_attributes)
-      permission_from_template(permission_template_attributes, :deposit_users).uniq
-    end
-
-    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
-    # @returns array of user keys
-    def self.group_depositors(permission_template_attributes)
-      permission_from_template(permission_template_attributes, :deposit_groups).uniq
-    end
-
-    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
-    # @returns array of user keys
-    def self.user_viewers(permission_template_attributes)
-      permission_from_template(permission_template_attributes, :view_users).uniq
-    end
-
-    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
-    # @returns array of user keys
-    def self.group_viewers(permission_template_attributes)
-      permission_from_template(permission_template_attributes, :view_groups).uniq
-    end
-
-    # Process the with_permission_template transient property such that...
-    # * a permission template is created for the admin set
-    # * a permission template access is created for the admin set creator
-    # * additional permission template accesses are created for each user/group identified in the attributes
-    #   of with_permission_template (created by the permission_template factory)
-    # @param [AdminSet] admin set object being built/created by the factory
-    # @param [Class] evaluator holding the transient properties for the current build/creation process
-    # @param [Boolean] if true, force the permission template to be created
-    def self.process_with_permission_template(adminset, evaluator, force = false)
-      return unless force || evaluator.with_permission_template
-      adminset.id ||= FactoryBot.generate(:object_id)
-      attributes = { source_id: adminset.id }
-      attributes[:manage_users] = user_managers(evaluator.with_permission_template, evaluator.user)
-      attributes = evaluator.with_permission_template.merge(attributes) if evaluator.with_permission_template.respond_to?(:merge)
-      FactoryBot.create(:permission_template, attributes) unless Hyrax::PermissionTemplate.find_by(source_id: adminset.id)
-    end
-
-    # Process the with_solr_document transient property such that...
-    # * a solr document is created for the admin set
-    # * permissions identified by with_permission_template, if any, are added to the solr fields
-    # @param [AdminSet] adminset object being built/created by the factory
-    # @param [Class] evaluator holding the transient properties for the current build/creation process
-    def self.process_with_solr_document(adminset, evaluator, creator_only = false)
-      return unless creator_only || evaluator.with_solr_document
-      ActiveFedora::SolrService.add(solr_document_with_permissions(adminset, evaluator, creator_only), commit: true)
-    end
-
-    # Return the admin set's solr document with permissions added, such that...
-    # * permissions identified by with_permission_template, if any, are added to the solr fields
-    # @param [AdminSet] adminset object being built/created by the factory
-    # @param [Class] evaluator holding the transient properties for the current build/creation process
-    # @returns the admin set's solr document with permissions added
-    def self.solr_document_with_permissions(adminset, evaluator, creator_only)
-      adminset.id ||= FactoryBot.generate(:object_id)
-      if creator_only
-        adminset.edit_users = [evaluator.user]
-      else
-        adminset.edit_users = user_managers(evaluator.with_permission_template, evaluator.user)
-        adminset.edit_groups = group_managers(evaluator.with_permission_template)
-        adminset.read_users = user_viewers(evaluator.with_permission_template) +
-                              user_depositors(evaluator.with_permission_template)
-        adminset.read_groups = group_viewers(evaluator.with_permission_template) +
-                               group_depositors(evaluator.with_permission_template) -
-                               [::Ability.registered_group_name, ::Ability.public_group_name]
-      end
-      adminset.to_solr
-    end
-    private_class_method :solr_document_with_permissions
-  end
-end