hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/controllers/hyrax/users_controller_spec.rb

@@ -0,0 +1,151 @@
+RSpec.describe Hyrax::UsersController, type: :controller do
+  let(:user) { create(:user) }
+
+  before { sign_in user }
+
+  describe "#show" do
+    it "show the user profile if user exists" do
+      get :show, params: { id: user.user_key }
+      expect(response).to be_success
+      expect(assigns[:presenter]).to be_kind_of Hyrax::UserProfilePresenter
+    end
+
+    it "redirects to root if user does not exist" do
+      get :show, params: { id: 'johndoe666' }
+      expect(response).to redirect_to(root_path)
+      expect(flash[:alert]).to include("User 'johndoe666' does not exist")
+    end
+  end
+
+  describe "#index" do
+    let!(:u1) { create(:user) }
+    let!(:u2) { create(:user) }
+
+    before do
+      allow(Flipflop).to receive(:hide_users_list?).and_return(false)
+    end
+
+    describe "requesting html" do
+      before do
+        # These user types are excluded:
+        User.audit_user
+        User.batch_user
+        create(:user, :guest)
+      end
+
+      it "excludes the audit_user and batch_user" do
+        get :index
+        expect(assigns[:users].to_a).to match_array [user, u1, u2]
+        expect(response).to be_successful
+      end
+
+      it "sorts by the user key when login is specified" do
+        get :index, params: { sort: 'login' }
+        expect(assigns[:users].to_a).to match_array [user, u1, u2]
+      end
+
+      it "sorts by the user key when login desc is specified" do
+        get :index, params: { sort: 'login desc' }
+        expect(assigns[:users].to_a).to match_array [user, u1, u2]
+      end
+    end
+
+    describe "requesting json" do
+      render_views
+
+      it "displays users" do
+        get :index, params: { format: :json }
+        expect(response).to be_successful
+        json = JSON.parse(response.body).fetch('users')
+        expect(json.map { |u| u['id'] }).to include(u1.id, u2.id)
+        expect(json.map { |u| u['text'] }).to include(u1.email, u2.email)
+      end
+    end
+
+    describe "query users" do
+      it "finds the expected user via email" do
+        get :index, params: { uq: u1.email }
+        expect(assigns[:users]).to include(u1)
+        expect(assigns[:users]).not_to include(u2)
+        expect(response).to be_successful
+      end
+
+      context "by display name" do
+        let!(:u1) { create(:user, display_name: "Dr. Curator") }
+        let!(:u2) { create(:user, display_name: "Jr. Architect") }
+
+        it "finds the expected user via display name" do
+          #
+          # allow_any_instance_of(User).to receive(:display_name).and_return("Dr. Curator", "Jr.Archivist")
+          get :index, params: { uq: u1.display_name }
+          expect(assigns[:users]).to include(u1)
+          expect(assigns[:users]).not_to include(u2)
+          expect(response).to be_successful
+        end
+      end
+
+      it "uses the base query" do
+        u3 = create(:user)
+        allow(controller).to receive(:base_query).and_return(["email == \"#{u3.email}\""])
+        get :index
+        expect(assigns[:users]).to include(u3)
+        expect(assigns[:users]).not_to include(u1, u2)
+        u3.destroy
+      end
+    end
+  end
+
+  describe 'user list access' do
+    context 'with hide_users_list?=enabled' do
+      before do
+        allow(Flipflop).to receive(:hide_users_list?).and_return(true)
+      end
+
+      describe 'with registered user' do
+        it 'renders the user list' do
+          get :index
+          expect(response.code).to eq '200'
+          expect(response).to render_template(:index)
+        end
+
+        it 'does return .json results' do
+          get :index, params: { format: :json }
+          expect(response).to be_successful
+        end
+      end
+
+      describe 'with unauthenticated user' do
+        before do
+          sign_out user
+        end
+
+        it 'does not render the user list' do
+          get :index
+          expect(flash[:alert]).to eq 'You need to sign in or sign up before continuing.'
+          expect(response).to have_http_status(302)
+          expect(response).to redirect_to('/users/sign_in')
+        end
+
+        it 'does not return .json results' do
+          get :index, params: { format: :json }
+          expect(response).not_to be_successful
+        end
+      end
+    end
+
+    context 'with hide_users_list?=disabled' do
+      before do
+        sign_out user
+        allow(Flipflop).to receive(:hide_users_list?).and_return(false)
+      end
+
+      describe 'with unauthenticated user' do
+        it 'renders the user list' do
+          get :index
+          expect(response.code).to eq '200'
+          expect(response).to render_template(:index)
+        end
+      end
+    end
+  end
+end

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