hyrax 2.9.3 → 3.0.0.pre.beta1

data/spec/controllers/hyrax/workflow_actions_controller_spec.rb

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,215 @@
+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