hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/presenters/hyrax/inspect_work_presenter_spec.rb

@@ -0,0 +1,59 @@
+RSpec.describe Hyrax::InspectWorkPresenter do
+  let(:solr_document) { SolrDocument.new(attributes) }
+  let(:attributes) do
+    { "id" => '888888',
+      "has_model_ssim" => ["GenericWork"] }
+  end
+
+  let(:user) { create(:user) }
+  let(:ability) { Ability.new(user) }
+  let(:presenter) { described_class.new(solr_document, ability) }
+  let(:entity) { instance_double(Sipity::Entity) }
+
+  describe "#workflow" do
+    let(:comments) do
+      { comment: 'comment', created_at: 'unknown' }
+    end
+    let(:roles) do
+      { id: '1', name: 'reviewing', users: ['user1', 'user2'] }
+    end
+
+    before do
+      allow(entity).to receive(:id).and_return('1')
+      allow(entity).to receive(:workflow_name).and_return('generic_workflow')
+      allow(entity).to receive(:workflow_id).and_return('1')
+      allow(entity).to receive(:proxy_for_global_id).and_return(attributes["id"])
+      allow(entity).to receive(:workflow_id).and_return('1')
+      allow(entity).to receive(:workflow_state_id).and_return('1')
+      allow(entity).to receive(:workflow_state_name).and_return('completed')
+      allow(presenter).to receive(:sipity_entity).and_return(entity)
+      allow(presenter).to receive(:workflow_comments).and_return(comments)
+      allow(presenter).to receive(:sipity_entity_roles).and_return(roles)
+    end
+
+    context "when a valid sipity_entity with workflow exists" do
+      subject { presenter.workflow }
+
+      it 'returns a hash of workflow related values for ispection' do
+        expect(subject[:entity_id]).to eq '1'
+        expect(subject[:workflow_name]).to eq 'generic_workflow'
+        expect(subject[:workflow_id]).to eq '1'
+        expect(subject[:proxy_for]).to eq attributes["id"]
+        expect(subject[:state_id]).to eq '1'
+        expect(subject[:state_name]).to eq 'completed'
+        expect(subject[:comments][:comment]).to eq 'comment'
+        expect(subject[:roles][:id]).to eq '1'
+        expect(subject[:roles][:name]).to eq 'reviewing'
+        expect(subject[:roles][:users][0]).to eq 'user1'
+      end
+    end
+
+    context "when no sipity_entity with workflow exists" do
+      let(:invalid) { described_class.new('no_solr_document', ability) }
+
+      it "raises PowerConverter::ConversionError" do
+        expect { invalid.workflow }.to raise_exception(PowerConverter::ConversionError)
+      end
+    end
+  end
+end

data/spec/presenters/hyrax/lease_presenter_spec.rb

@@ -0,0 +1,51 @@
+RSpec.describe Hyrax::LeasePresenter do
+  let(:document) { SolrDocument.new(attributes) }
+  let(:presenter) { described_class.new(document) }
+  let(:attributes) { {} }
+
+  describe "visibility" do
+    subject { presenter.visibility }
+
+    it { is_expected.to eq 'restricted' }
+  end
+
+  describe "to_s" do
+    let(:attributes) { { 'title_tesim' => ['Hey guys!'] } }
+
+    subject { presenter.to_s }
+
+    it { is_expected.to eq 'Hey guys!' }
+  end
+
+  describe "human_readable_type" do
+    let(:attributes) { { 'human_readable_type_tesim' => ['File'] } }
+
+    subject { presenter.human_readable_type }
+
+    it { is_expected.to eq 'File' }
+  end
+
+  describe "lease_expiration_date" do
+    let(:attributes) { { 'lease_expiration_date_dtsi' => '2015-10-15T00:00:00Z' } }
+
+    subject { presenter.lease_expiration_date }
+
+    it { is_expected.to eq '15 Oct 2015' }
+  end
+
+  describe "visibility_after_lease" do
+    let(:attributes) { { 'visibility_after_lease_ssim' => ['restricted'] } }
+
+    subject { presenter.visibility_after_lease }
+
+    it { is_expected.to eq 'restricted' }
+  end
+
+  describe "lease_history" do
+    let(:attributes) { { 'lease_history_ssim' => ['This is in the past'] } }
+
+    subject { presenter.lease_history }
+
+    it { is_expected.to eq ['This is in the past'] }
+  end
+end

data/spec/presenters/hyrax/member_presenter_factory_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe Hyrax::MemberPresenterFactory do
+  describe "#file_set_presenters" do
+    describe "getting presenters from factory" do
+      let(:solr_document) { SolrDocument.new(attributes) }
+      let(:attributes) { {} }
+      let(:ability) { double }
+      let(:request) { double }
+      let(:factory) { described_class.new(solr_document, ability, request) }
+      let(:presenter_class) { double }
+
+      before do
+        allow(factory).to receive(:composite_presenter_class).and_return(presenter_class)
+        allow(factory).to receive(:ordered_ids).and_return(['12', '33'])
+        allow(factory).to receive(:file_set_ids).and_return(['33', '12'])
+      end
+
+      it "uses the set class" do
+        expect(Hyrax::PresenterFactory).to receive(:build_for)
+          .with(ids: ['12', '33'],
+                presenter_class: presenter_class,
+                presenter_args: [ability, request])
+        factory.file_set_presenters
+      end
+    end
+  end
+end

data/spec/presenters/hyrax/menu_presenter_spec.rb

@@ -0,0 +1,107 @@
+RSpec.describe Hyrax::MenuPresenter do
+  let(:instance) { described_class.new(context) }
+  let(:context) { ActionView::TestCase::TestController.new.view_context }
+  let(:controller_name) { controller.controller_name }
+
+  describe "#settings_section?" do
+    before do
+      allow(context).to receive(:controller_name).and_return(controller_name)
+    end
+    subject { instance.settings_section? }
+
+    context "for the ContentBlocksController" do
+      let(:controller_name) { Hyrax::ContentBlocksController.controller_name }
+
+      it { is_expected.to be true }
+    end
+    context "for the PagesController" do
+      let(:controller_name) { Hyrax::PagesController.controller_name }
+
+      it { is_expected.to be true }
+    end
+    context "for the CollectionTypesController" do
+      let(:controller_name) { Hyrax::Admin::CollectionTypesController.controller_name }
+
+      it { is_expected.to be true }
+    end
+  end
+
+  describe "#collapsable_section" do
+    subject do
+      instance.collapsable_section('link title',
+                                   id: 'mySection',
+                                   icon_class: 'fa fa-cog',
+                                   open: open) do
+                                     "Some content"
+                                   end
+    end
+
+    let(:rendered) { Capybara::Node::Simple.new(subject) }
+
+    context "when collapsed" do
+      let(:open) { false }
+
+      it "draws a collapsable section" do
+        expect(rendered).to have_content "Some content"
+        expect(rendered).to have_selector "span.fa.fa-cog"
+        expect(rendered).to have_selector "a.collapsed.collapse-toggle[href='#mySection']"
+        expect(rendered).to have_selector "ul#mySection"
+      end
+    end
+
+    context "when open" do
+      let(:open) { true }
+
+      it "draws a collapsable section" do
+        expect(rendered).to have_content "Some content"
+        expect(rendered).to have_selector "span.fa.fa-cog"
+        expect(rendered).to have_selector "a.collapse-toggle[href='#mySection']"
+        expect(rendered).to have_selector "ul#mySection.in"
+      end
+    end
+  end
+
+  describe "#user_activity_section?" do
+    before do
+      allow(context).to receive(:controller_name).and_return(controller_name)
+      allow(context).to receive(:controller).and_return(controller)
+    end
+    subject { instance.user_activity_section? }
+
+    context "for the Hyrax::UsersController" do
+      let(:controller) { Hyrax::UsersController.new }
+
+      it { is_expected.to be true }
+    end
+
+    context "for the Admin::UsersController" do
+      let(:controller) { Hyrax::Admin::UsersController.new }
+
+      it { is_expected.to be false }
+    end
+
+    context "for the Hyrax::DepositorsController" do
+      let(:controller) { Hyrax::DepositorsController.new }
+
+      it { is_expected.to be true }
+    end
+  end
+
+  describe "#show_configuration?" do
+    subject { instance.show_configuration? }
+
+    context "for a regular user" do
+      before do
+        allow(instance.view_context).to receive(:can?).and_return(false)
+      end
+      it { is_expected.to be false }
+    end
+
+    context "for a user who can manage users" do
+      before do
+        allow(instance.view_context).to receive(:can?).and_return(true)
+      end
+      it { is_expected.to be true }
+    end
+  end
+end

data/spec/presenters/hyrax/permission_badge_spec.rb

@@ -0,0 +1,77 @@
+RSpec.describe Hyrax::PermissionBadge do
+  context "with a SolrDocument" do
+    let(:badge) { described_class.new(solr_doc.visibility) }
+    let(:solr_doc) { SolrDocument.new(attributes) }
+    let(:attributes) { {} }
+
+    describe "#render" do
+      subject { badge.render }
+
+      context "when under embargo" do
+        let(:attributes) { { read_access_group_ssim: ['public'], embargo_release_date_dtsi: '2016-05-04' } }
+
+        it { is_expected.to eq "<span class=\"label label-warning\">Embargo</span>" }
+      end
+
+      context "when under lease" do
+        let(:attributes) { { read_access_group_ssim: ['public'], lease_expiration_date_dtsi: '2016-05-04' } }
+
+        it { is_expected.to eq "<span class=\"label label-warning\">Lease</span>" }
+      end
+
+      context "when open-access" do
+        let(:attributes) { { read_access_group_ssim: ['public'] } }
+
+        it { is_expected.to eq "<span class=\"label label-success\">Public</span>" }
+      end
+
+      context "when registered" do
+        let(:attributes) { { read_access_group_ssim: ['registered'] } }
+
+        it { is_expected.to eq "<span class=\"label label-info\">Institution</span>" }
+      end
+
+      context "when private" do
+        it { is_expected.to eq "<span class=\"label label-danger\">Private</span>" }
+      end
+    end
+  end
+
+  context "with a string" do
+    let(:badge) { described_class.new(value) }
+
+    describe "#render" do
+      subject { badge.render }
+
+      context "when under embargo" do
+        let(:value) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO }
+
+        it { is_expected.to eq "<span class=\"label label-warning\">Embargo</span>" }
+      end
+
+      context "when under lease" do
+        let(:value) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE }
+
+        it { is_expected.to eq "<span class=\"label label-warning\">Lease</span>" }
+      end
+
+      context "when open-access" do
+        let(:value) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+
+        it { is_expected.to eq "<span class=\"label label-success\">Public</span>" }
+      end
+
+      context "when registered" do
+        let(:value) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+
+        it { is_expected.to eq "<span class=\"label label-info\">Institution</span>" }
+      end
+
+      context "when private" do
+        let(:value) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+
+        it { is_expected.to eq "<span class=\"label label-danger\">Private</span>" }
+      end
+    end
+  end
+end

data/spec/presenters/hyrax/presenter_factory_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe Hyrax::PresenterFactory do
+  describe "#build_for" do
+    let(:presenter_class) { Hyrax::FileSetPresenter }
+
+    before do
+      allow(ActiveFedora::SolrService.instance.conn).to receive(:post)
+        .with('select', data: { q: "{!terms f=id}12,13", rows: 1000, qt: 'standard' })
+        .and_return('response' => { 'docs' => results })
+    end
+
+    subject { described_class.build_for(ids: ['12', '13'], presenter_class: presenter_class, presenter_args: nil) }
+
+    context "when some ids are found in solr" do
+      let(:results) { [{ "id" => "12" }, { "id" => "13" }] }
+
+      it "has two results" do
+        expect(subject.size).to eq 2
+      end
+    end
+
+    context "when some ids are not found in solr" do
+      let(:results) { [{ "id" => "13" }] }
+
+      it "has one result" do
+        expect(subject.size).to eq 1
+      end
+    end
+
+    context "with more arguments" do
+      let(:presenter_class) do
+        Class.new(Hyrax::FileSetPresenter) do
+          attr_reader :two, :three
+          def initialize(_one, two, three)
+            @two = two
+            @three = three
+          end
+        end
+      end
+      let(:results) { [{ "id" => "12" }, { "id" => "13" }] }
+
+      subject do
+        described_class.build_for(ids: ['12', '13'],
+                                  presenter_class: presenter_class,
+                                  presenter_args: ['more', 'and more'])
+      end
+
+      it 'passes all the arguments' do
+        expect(subject.first.two).to eq 'more'
+        expect(subject.first.three).to eq 'and more'
+      end
+    end
+  end
+end

data/spec/presenters/hyrax/presenter_renderer_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Hyrax::PresenterRenderer, type: :view do
+  let(:ability) { double }
+  let(:document) { SolrDocument.new(data) }
+  let(:data) do
+    { id: '123', date_created_tesim: 'foo', date_uploaded_tesim: 'bar', has_model_ssim: 'GenericWork' }
+  end
+  let(:presenter) { Hyrax::WorkShowPresenter.new(document, ability) }
+  let(:renderer) { described_class.new(presenter, view) }
+
+  describe "#label" do
+    it "calls translate with defaults" do
+      expect(renderer).to receive(:t).with(:"generic_work.date_created",
+                                           default: [:"defaults.date_created", "Date created"],
+                                           scope: :"simple_form.labels")
+      renderer.label(:date_created)
+    end
+
+    context "of a field with a translation" do
+      subject { renderer.label(:date_created) }
+
+      it { is_expected.to eq 'Date Created' }
+    end
+
+    context "of a field without a translation" do
+      subject { renderer.label(:date_uploaded) }
+
+      it { is_expected.to eq 'Date uploaded' }
+    end
+  end
+end

data/spec/presenters/hyrax/select_collection_type_list_presenter_spec.rb

@@ -0,0 +1,59 @@
+RSpec.describe Hyrax::SelectCollectionTypeListPresenter, :clean_repo do
+  let(:user) { create(:user) }
+  let(:instance) { described_class.new(user) }
+  let(:collection_type) { create(:collection_type, creator_user: user) }
+  let(:user_collection_type) { create(:user_collection_type) }
+
+  describe "#many?" do
+    let(:subject) { instance.many? }
+
+    it "finds only one" do
+      expect(subject).to be false
+    end
+
+    it "finds many" do
+      collection_type
+      user_collection_type
+      expect(subject).to be true
+    end
+  end
+
+  describe "#any?" do
+    let(:subject) { instance.any? }
+
+    it 'finds no collection types' do
+      expect(subject).to be false
+    end
+
+    it 'finds a collection type' do
+      collection_type
+      expect(subject).to be true
+    end
+  end
+
+  describe "authorized_collection_types" do
+    let(:subject) { instance.authorized_collection_types }
+
+    it 'returns an array of Hyrax::CollectionTypes' do
+      expect(Hyrax::CollectionTypes::PermissionsService).to receive(:can_create_collection_types).with(user: user).and_return(:the_response)
+      expect(subject).to equal(:the_response)
+    end
+  end
+
+  describe "#first_collection_type" do
+    let(:subject) { instance.first_collection_type }
+
+    it 'returns the first collection_type' do
+      collection_type
+      user_collection_type
+      expect(subject).to eq(Hyrax::CollectionType.first)
+    end
+  end
+
+  describe "#each" do
+    it 'iterates through all collection types' do
+      expect(Hyrax::CollectionTypes::PermissionsService).to receive(:can_create_collection_types).with(user: user).and_return([:the_response])
+      expect { |block| instance.each(&block) }.to yield_successive_args(kind_of(Hyrax::SelectCollectionTypePresenter))
+    end
+  end
+end

data/spec/presenters/hyrax/select_collection_type_presenter_spec.rb

@@ -0,0 +1,10 @@
+RSpec.describe Hyrax::SelectCollectionTypePresenter do
+  subject { described_class.new(collection_type) }
+
+  let(:collection_type) { create(:collection_type) }
+
+  it { is_expected.to delegate_method(:title).to(:collection_type) }
+  it { is_expected.to delegate_method(:description).to(:collection_type) }
+  it { is_expected.to delegate_method(:admin_set?).to(:collection_type) }
+  it { is_expected.to delegate_method(:id).to(:collection_type) }
+end

data/spec/presenters/hyrax/select_type_list_presenter_spec.rb

@@ -0,0 +1,37 @@
+# Note: test app generates multiple work types (concerns) now
+RSpec.describe Hyrax::SelectTypeListPresenter do
+  let(:instance) { described_class.new(user) }
+  let(:user) { nil }
+
+  describe "#many?" do
+    subject { instance.many? }
+
+    context 'without a logged in user' do
+      it { is_expected.to be false }
+
+      context "if user is nil" do
+        it { is_expected.to be false }
+      end
+    end
+
+    context 'with a logged in user' do
+      let(:user) { create(:user) }
+
+      it { is_expected.to be true }
+      context "if authorized_models returns only one" do
+        before do
+          allow(instance).to receive(:authorized_models).and_return([double])
+        end
+        it { is_expected.to be false }
+      end
+    end
+  end
+
+  describe "#first_model" do
+    let(:user) { create(:user) }
+
+    subject { instance.first_model }
+
+    it { is_expected.to be GenericWork }
+  end
+end

data/spec/presenters/hyrax/select_type_presenter_spec.rb

@@ -0,0 +1,74 @@
+RSpec.describe Hyrax::SelectTypePresenter do
+  let(:instance) { described_class.new(model) }
+  let(:model) { GenericWork }
+
+  describe "#icon_class" do
+    subject { instance.icon_class }
+
+    it { is_expected.to eq 'fa fa-file-text-o' }
+  end
+
+  describe "#description" do
+    subject { instance.description }
+
+    it { is_expected.to eq 'Generic work works' }
+  end
+
+  describe "#name" do
+    subject { instance.name }
+
+    it { is_expected.to eq 'Generic Work' }
+  end
+
+  describe '#switch_to_new_work_path' do
+    subject { instance.switch_to_new_work_path(route_set: routes, params: params) }
+
+    let(:collection_id) { 'xyz123abc' }
+    let(:routes) do
+      Rails.application.routes.url_helpers.extend(ActionDispatch::Routing::PolymorphicRoutes)
+    end
+
+    context 'with add_works_to_collection param' do
+      let(:params) { { add_works_to_collection: collection_id } }
+
+      it { is_expected.to eq "/concern/#{model.to_s.tableize}/new?add_works_to_collection=#{collection_id}" }
+    end
+
+    context 'with id and controller params' do
+      let(:params) { { id: collection_id, controller: 'hyrax/dashboard/collections' } }
+
+      it { is_expected.to eq "/concern/#{model.to_s.tableize}/new?add_works_to_collection=#{collection_id}" }
+    end
+
+    context 'with no params' do
+      let(:params) { {} }
+
+      it { is_expected.to eq "/concern/#{model.to_s.tableize}/new" }
+    end
+  end
+
+  describe '#switch_to_batch_upload_path' do
+    subject { instance.switch_to_batch_upload_path(route_set: routes, params: params) }
+
+    let(:collection_id) { 'xyz123abc' }
+    let(:routes) { Hyrax::Engine.routes.url_helpers }
+
+    context 'with add_works_to_collection param' do
+      let(:params) { { add_works_to_collection: collection_id } }
+
+      it { is_expected.to eq "/batch_uploads/new?add_works_to_collection=#{collection_id}&payload_concern=#{model}" }
+    end
+
+    context 'with id and controller params' do
+      let(:params) { { id: collection_id, controller: 'hyrax/dashboard/collections' } }
+
+      it { is_expected.to eq "/batch_uploads/new?add_works_to_collection=#{collection_id}&payload_concern=#{model}" }
+    end
+
+    context 'with no params' do
+      let(:params) { {} }
+
+      it { is_expected.to eq "/batch_uploads/new?payload_concern=#{model}" }
+    end
+  end
+end

data/spec/presenters/hyrax/single_use_link_presenter_spec.rb

@@ -0,0 +1,41 @@
+RSpec.describe Hyrax::SingleUseLinkPresenter do
+  subject { described_class.new(link) }
+
+  context "with any kind of link" do
+    let(:link) { create(:download_link) }
+
+    describe "#human_readable_expiration" do
+      context "in more than one hour" do
+        its(:human_readable_expiration) { is_expected.to eq("in 23 hours") }
+      end
+      context "in less than an hour" do
+        before { allow(link).to receive(:expires).and_return(Time.zone.now) }
+        its(:human_readable_expiration) { is_expected.to eq("in less than one hour") }
+      end
+    end
+
+    describe "#short_key" do
+      its(:short_key) { is_expected.to eq(link.download_key.first(6)) }
+    end
+
+    describe "delegated methods" do
+      its(:download_key) { is_expected.to eq(link.download_key) }
+      its(:expired?)    { is_expected.to eq(link.expired?) }
+      its(:to_param)    { is_expected.to eq(link.to_param) }
+    end
+  end
+
+  context "with a download link" do
+    let(:link)        { create(:download_link) }
+
+    its(:link_type)   { is_expected.to eq("Download") }
+    its(:url_helper)  { is_expected.to eq("download_single_use_link_url") }
+  end
+
+  context "with a show link" do
+    let(:link)        { create(:show_link) }
+
+    its(:link_type)   { is_expected.to eq("Show") }
+    its(:url_helper)  { is_expected.to eq("show_single_use_link_url") }
+  end
+end

data/spec/presenters/hyrax/transfers_presenter_spec.rb

@@ -0,0 +1,44 @@
+RSpec.describe Hyrax::TransfersPresenter do
+  let(:context) { ActionView::TestCase::TestController.new.view_context }
+  let(:user) { create(:user) }
+  let(:instance) { described_class.new(user, context) }
+
+  describe "#incoming_proxy_deposits" do
+    subject(:incoming_proxy_deposits) { instance.send(:incoming_proxy_deposits) }
+
+    let(:another_user) { create(:user) }
+    let!(:incoming_work) do
+      create(:work, user: another_user).tap do |w|
+        w.request_transfer_to(user)
+      end
+    end
+
+    it 'returns a list of ProxyDepositRequests' do
+      expect(incoming_proxy_deposits.first).to be_kind_of ProxyDepositRequest
+      expect(incoming_proxy_deposits.first.work_id).to eq(incoming_work.id)
+    end
+
+    context "When the incoming request is for a deleted work" do
+      before { incoming_work.destroy }
+      it "does not show that work" do
+        expect(incoming_proxy_deposits).to be_empty
+      end
+    end
+  end
+
+  describe "#outgoing_proxy_deposits" do
+    subject { instance.send(:outgoing_proxy_deposits) }
+
+    let(:another_user) { create(:user) }
+    let!(:outgoing_work) do
+      create(:work, user: user).tap do |w|
+        w.request_transfer_to(another_user)
+      end
+    end
+
+    it 'returns a list of ProxyDepositRequests' do
+      expect(subject.first).to be_kind_of ProxyDepositRequest
+      expect(subject.first.work_id).to eq(outgoing_work.id)
+    end
+  end
+end