hyrax 2.9.5 → 3.0.0.pre.beta1

data/spec/presenters/hyrax/twitter_presenter_spec.rb

@@ -0,0 +1,27 @@
+module Hyrax
+  RSpec.describe TwitterPresenter do
+    describe '.twitter_handle_for' do
+      let(:user_key) { 'user_key' }
+
+      subject { described_class.twitter_handle_for(user_key: user_key) }
+
+      context "with a found user that has a twitter handle" do
+        before { allow(::User).to receive(:find_by_user_key).with(user_key).and_return(user) }
+        let(:user) { instance_double(::User, twitter_handle: 'test', user_key: user_key) }
+
+        it { is_expected.to eq '@test' }
+      end
+
+      context "with a found user that doesn't have a twitter handle" do
+        before { allow(::User).to receive(:find_by_user_key).with(user_key).and_return(user) }
+        let(:user) { instance_double(::User, twitter_handle: '', user_key: user_key) }
+
+        it { is_expected.to eq '@SamveraRepo' }
+      end
+
+      context "with a user that can't be found" do
+        it { is_expected.to eq '@SamveraRepo' }
+      end
+    end
+  end
+end

data/spec/presenters/hyrax/user_profile_presenter_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Hyrax::UserProfilePresenter do
+  let(:user) { create(:user) }
+  let(:ability) { Ability.new(user) }
+  let(:presenter) { described_class.new(user, ability) }
+
+  describe "current_user?" do
+    subject { presenter.current_user? }
+
+    it { is_expected.to be true }
+  end
+
+  describe "trophies" do
+    let(:work1) { create(:work, user: user) }
+    let(:work2) { create(:work, user: user) }
+    let(:work3) { create(:work, user: user) }
+    let!(:trophy1) { user.trophies.create!(work_id: work1.id) }
+    let!(:trophy2) { user.trophies.create!(work_id: work2.id) }
+    let!(:trophy3) { user.trophies.create!(work_id: work3.id) }
+    let!(:badtrophy) { user.trophies.create!(work_id: 'not_a_generic_work') }
+
+    subject { presenter.trophies }
+
+    it "has an array of presenters" do
+      expect(subject).to all(be_kind_of Hyrax::TrophyPresenter)
+      expect(subject.map(&:id)).to match_array [work1.id, work2.id, work3.id]
+    end
+  end
+end

data/spec/presenters/hyrax/version_list_presenter_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Hyrax::VersionListPresenter do
+  let(:resource_version) do
+    ActiveFedora::VersionsGraph::ResourceVersion.new.tap do |v|
+      v.uri = 'http://example.com/version1'
+      v.label = 'version1'
+      v.created = '2014-12-09T02:03:18.296Z'
+    end
+  end
+
+  let(:resource_version2) do
+    ActiveFedora::VersionsGraph::ResourceVersion.new.tap do |v|
+      v.uri = 'http://example.com/version2'
+      v.label = 'version2'
+      v.created = '2014-12-19T02:03:18.296Z'
+    end
+  end
+
+  subject { described_class.new([resource_version, resource_version2]) }
+
+  describe "#each" do
+    it "yields version_presenters" do
+      versions_descending = []
+      subject.each do |v|
+        expect(v).to be_kind_of Hyrax::VersionPresenter
+        versions_descending.push(v.label)
+      end
+      expect(versions_descending).to eq ['version2', 'version1']
+    end
+  end
+end

data/spec/presenters/hyrax/version_presenter_spec.rb

@@ -0,0 +1,57 @@
+RSpec.describe Hyrax::VersionPresenter do
+  let(:resource_version) do
+    ActiveFedora::VersionsGraph::ResourceVersion.new.tap do |v|
+      v.uri = 'http://example.com/version1'
+      v.label = 'version1'
+      v.created = '2014-12-09T02:03:18.296Z'
+    end
+  end
+
+  let(:presenter) { described_class.new(resource_version) }
+
+  describe "#label" do
+    subject { presenter.label }
+
+    it { is_expected.to eq 'version1' }
+  end
+
+  describe "#uri" do
+    subject { presenter.uri }
+
+    it { is_expected.to eq 'http://example.com/version1' }
+  end
+
+  describe "#created" do
+    around do |example|
+      # Stub out the local timezone to (+08:00)
+      tmp_zone = Time.zone
+      Time.zone = "America/Los_Angeles"
+      example.call
+      Time.zone = tmp_zone
+    end
+
+    subject { presenter.created }
+
+    it { is_expected.to eq "December 8th, 2014 18:03" }
+  end
+
+  describe "#current?" do
+    subject { presenter.current? }
+
+    it { is_expected.to be false }
+
+    context "when current! is set" do
+      before { presenter.current! }
+      it { is_expected.to be true }
+    end
+  end
+
+  describe "#committer" do
+    before do
+      Hyrax::VersionCommitter.create(version_id: resource_version.uri, committer_login: 'jill')
+    end
+    subject { presenter.committer }
+
+    it { is_expected.to eq 'jill' }
+  end
+end

data/spec/presenters/hyrax/work_show_presenter_spec.rb

@@ -0,0 +1,580 @@
+RSpec.describe Hyrax::WorkShowPresenter do
+  let(:solr_document) { SolrDocument.new(attributes) }
+  let(:request) { double(host: 'example.org', base_url: 'http://example.org') }
+  let(:user_key) { 'a_user_key' }
+
+  let(:attributes) do
+    { "id" => '888888',
+      "title_tesim" => ['foo', 'bar'],
+      "human_readable_type_tesim" => ["Generic Work"],
+      "has_model_ssim" => ["GenericWork"],
+      "date_created_tesim" => ['an unformatted date'],
+      "depositor_tesim" => user_key }
+  end
+  let(:ability) { double Ability }
+  let(:presenter) { described_class.new(solr_document, ability, request) }
+
+  subject { described_class.new(double, double) }
+
+  it { is_expected.to delegate_method(:to_s).to(:solr_document) }
+  it { is_expected.to delegate_method(:human_readable_type).to(:solr_document) }
+  it { is_expected.to delegate_method(:date_created).to(:solr_document) }
+  it { is_expected.to delegate_method(:date_modified).to(:solr_document) }
+  it { is_expected.to delegate_method(:date_uploaded).to(:solr_document) }
+  it { is_expected.to delegate_method(:rights_statement).to(:solr_document) }
+
+  it { is_expected.to delegate_method(:based_near_label).to(:solr_document) }
+  it { is_expected.to delegate_method(:related_url).to(:solr_document) }
+  it { is_expected.to delegate_method(:depositor).to(:solr_document) }
+  it { is_expected.to delegate_method(:identifier).to(:solr_document) }
+  it { is_expected.to delegate_method(:resource_type).to(:solr_document) }
+  it { is_expected.to delegate_method(:keyword).to(:solr_document) }
+  it { is_expected.to delegate_method(:itemtype).to(:solr_document) }
+  it { is_expected.to delegate_method(:member_presenters).to(:member_presenter_factory) }
+  it { is_expected.to delegate_method(:ordered_ids).to(:member_presenter_factory) }
+
+  describe "#model_name" do
+    subject { presenter.model_name }
+
+    it { is_expected.to be_kind_of ActiveModel::Name }
+  end
+
+  describe '#manifest_url' do
+    subject { presenter.manifest_url }
+
+    it { is_expected.to eq 'http://example.org/concern/generic_works/888888/manifest' }
+  end
+
+  describe '#iiif_viewer?' do
+    let(:id_present) { false }
+    let(:representative_presenter) { double('representative', present?: false) }
+    let(:image_boolean) { false }
+    let(:iiif_enabled) { true }
+    let(:file_set_presenter) { Hyrax::FileSetPresenter.new(solr_document, ability) }
+    let(:file_set_presenters) { [file_set_presenter] }
+    let(:read_permission) { true }
+
+    before do
+      allow(presenter).to receive(:representative_id).and_return(id_present)
+      allow(presenter).to receive(:representative_presenter).and_return(representative_presenter)
+      allow(presenter).to receive(:file_set_presenters).and_return(file_set_presenters)
+      allow(file_set_presenter).to receive(:image?).and_return(true)
+      allow(ability).to receive(:can?).with(:read, solr_document.id).and_return(read_permission)
+      allow(representative_presenter).to receive(:image?).and_return(image_boolean)
+      allow(Hyrax.config).to receive(:iiif_image_server?).and_return(iiif_enabled)
+    end
+
+    subject { presenter.iiif_viewer? }
+
+    context 'with no representative_id' do
+      it { is_expected.to be false }
+    end
+
+    context 'with no representative_presenter' do
+      let(:id_present) { true }
+
+      it { is_expected.to be false }
+    end
+
+    context 'with non-image representative_presenter' do
+      let(:id_present) { true }
+      let(:representative_presenter) { double('representative', present?: true) }
+      let(:image_boolean) { false }
+
+      it { is_expected.to be false }
+    end
+
+    context 'with IIIF image server turned off' do
+      let(:id_present) { true }
+      let(:representative_presenter) { double('representative', present?: true) }
+      let(:image_boolean) { true }
+      let(:iiif_enabled) { false }
+
+      it { is_expected.to be false }
+    end
+
+    context 'with representative image and IIIF turned on' do
+      let(:id_present) { true }
+      let(:representative_presenter) { double('representative', present?: true) }
+      let(:image_boolean) { true }
+      let(:iiif_enabled) { true }
+
+      it { is_expected.to be true }
+
+      context "when the user doesn't have permission to view the image" do
+        let(:read_permission) { false }
+
+        it { is_expected.to be false }
+      end
+    end
+  end
+
+  describe '#stats_path' do
+    let(:user) { 'sarah' }
+    let(:ability) { double "Ability" }
+    let(:work) { build(:generic_work, id: '123abc') }
+    let(:attributes) { work.to_solr }
+
+    before do
+      # https://github.com/samvera/active_fedora/issues/1251
+      allow(work).to receive(:persisted?).and_return(true)
+    end
+
+    it { expect(presenter.stats_path).to eq Hyrax::Engine.routes.url_helpers.stats_work_path(id: work, locale: 'en') }
+  end
+
+  describe '#itemtype' do
+    let(:work) { build(:generic_work, resource_type: type) }
+    let(:attributes) { work.to_solr }
+    let(:ability) { double "Ability" }
+
+    subject { presenter.itemtype }
+
+    context 'when resource_type is Audio' do
+      let(:type) { ['Audio'] }
+
+      it do
+        is_expected.to eq 'http://schema.org/AudioObject'
+      end
+    end
+
+    context 'when resource_type is Conference Proceeding' do
+      let(:type) { ['Conference Proceeding'] }
+
+      it { is_expected.to eq 'http://schema.org/ScholarlyArticle' }
+    end
+  end
+
+  describe 'admin users' do
+    let(:user)    { create(:user) }
+    let(:ability) { Ability.new(user) }
+    let(:attributes) do
+      {
+        "read_access_group_ssim" => ["public"],
+        'id' => '99999'
+      }
+    end
+
+    before { allow(user).to receive_messages(groups: ['admin', 'registered']) }
+
+    context 'with a new public work' do
+      it 'can feature the work' do
+        allow(user).to receive(:can?).with(:create, FeaturedWork).and_return(true)
+        expect(presenter.work_featurable?).to be true
+        expect(presenter.display_feature_link?).to be true
+        expect(presenter.display_unfeature_link?).to be false
+      end
+    end
+
+    context 'with a featured work' do
+      before { FeaturedWork.create(work_id: attributes.fetch('id')) }
+      it 'can unfeature the work' do
+        expect(presenter.work_featurable?).to be true
+        expect(presenter.display_feature_link?).to be false
+        expect(presenter.display_unfeature_link?).to be true
+      end
+    end
+
+    describe "#editor?" do
+      subject { presenter.editor? }
+
+      it { is_expected.to be true }
+    end
+  end
+
+  describe '#tweeter' do
+    let(:user) { instance_double(User, user_key: 'user_key') }
+
+    subject { presenter.tweeter }
+
+    it 'delegates the depositor as the user_key to TwitterPresenter.twitter_handle_for' do
+      expect(Hyrax::TwitterPresenter).to receive(:twitter_handle_for).with(user_key: user_key)
+      subject
+    end
+  end
+
+  describe "#permission_badge" do
+    let(:badge) { instance_double(Hyrax::PermissionBadge) }
+
+    before do
+      allow(Hyrax::PermissionBadge).to receive(:new).and_return(badge)
+    end
+    it "calls the PermissionBadge object" do
+      expect(badge).to receive(:render)
+      presenter.permission_badge
+    end
+  end
+
+  describe "#work_presenters" do
+    let(:obj) { create(:work_with_file_and_work) }
+    let(:attributes) { obj.to_solr }
+
+    it "filters out members that are file sets" do
+      expect(presenter.work_presenters.size).to eq 1
+      expect(presenter.work_presenters.first).to be_instance_of(described_class)
+    end
+  end
+
+  describe "#member_presenters" do
+    let(:obj) { create(:work_with_file_and_work) }
+    let(:attributes) { obj.to_solr }
+
+    it "returns appropriate classes for each" do
+      expect(presenter.member_presenters.size).to eq 2
+      expect(presenter.member_presenters.first).to be_instance_of(Hyrax::FileSetPresenter)
+      expect(presenter.member_presenters.last).to be_instance_of(described_class)
+    end
+  end
+
+  describe "#member_presenters_for" do
+    let(:obj) { create(:work_with_file_and_work) }
+    let(:attributes) { obj.to_solr }
+    let(:items) { presenter.ordered_ids }
+    let(:subject) { presenter.member_presenters_for(items) }
+
+    it "returns appropriate classes for each item" do
+      expect(subject.size).to eq 2
+      expect(subject.first).to be_instance_of(Hyrax::FileSetPresenter)
+      expect(subject.last).to be_instance_of(described_class)
+    end
+  end
+
+  describe "#list_of_item_ids_to_display" do
+    let(:subject) { presenter.list_of_item_ids_to_display }
+    let(:items_list) { ['item0', 'item1', 'item2', 'item3', 'item4', 'item5', 'item6', 'item7', 'item8', 'item9'] }
+    let(:rows) { 10 }
+    let(:page) { 1 }
+    let(:ability) { double "Ability" }
+    let(:current_ability) { ability }
+
+    before do
+      allow(presenter).to receive(:ordered_ids).and_return(items_list)
+      allow(current_ability).to receive(:can?).with(:read, 'item0').and_return true
+      allow(current_ability).to receive(:can?).with(:read, 'item1').and_return false
+      allow(current_ability).to receive(:can?).with(:read, 'item2').and_return true
+      allow(current_ability).to receive(:can?).with(:read, 'item3').and_return false
+      allow(current_ability).to receive(:can?).with(:read, 'item4').and_return true
+      allow(current_ability).to receive(:can?).with(:read, 'item5').and_return true
+      allow(current_ability).to receive(:can?).with(:read, 'item6').and_return false
+      allow(current_ability).to receive(:can?).with(:read, 'item7').and_return true
+      allow(current_ability).to receive(:can?).with(:read, 'item8').and_return false
+      allow(current_ability).to receive(:can?).with(:read, 'item9').and_return true
+      allow(presenter).to receive(:rows_from_params).and_return(rows)
+      allow(presenter).to receive(:current_page).and_return(page)
+      allow(Flipflop).to receive(:hide_private_items?).and_return(answer)
+    end
+
+    context 'when hiding private items' do
+      let(:answer) { true }
+
+      it "returns viewable items" do
+        expect(subject.size).to eq 6
+        expect(subject).to be_instance_of(Kaminari::PaginatableArray)
+        expect(subject).to include("item0", "item2", "item4", "item5", "item7", "item9")
+      end
+    end
+    context 'when including private items' do
+      let(:answer) { false }
+
+      it "returns appropriate items" do
+        expect(subject.size).to eq 10
+        expect(subject).to be_instance_of(Kaminari::PaginatableArray)
+        expect(subject).to eq(items_list)
+      end
+    end
+    context 'with pagination' do
+      let(:rows) { 3 }
+      let(:page) { 2 }
+
+      let(:answer) { true }
+      it 'partitions the item list and excluding hidden items' do
+        expect(subject).to eq(['item5', 'item7', 'item9'])
+      end
+    end
+  end
+
+  describe "#total_pages" do
+    let(:subject) { presenter.total_pages }
+    let(:items) { 17 }
+    let(:rows) { 4 }
+
+    before do
+      allow(Flipflop).to receive(:hide_private_items?).and_return(false)
+      allow(presenter).to receive(:total_items).and_return(items)
+      allow(presenter).to receive(:rows_from_params).and_return(rows)
+    end
+
+    it 'calculates number of pages from items and rows' do
+      expect(subject).to eq(5)
+    end
+  end
+
+  describe "#file_set_presenters" do
+    let(:obj) { create(:work_with_ordered_files) }
+    let(:attributes) { obj.to_solr }
+
+    it "displays them in order" do
+      expect(presenter.file_set_presenters.map(&:id)).to eq obj.ordered_member_ids
+    end
+
+    context "solr query" do
+      before do
+        expect(ActiveFedora::SolrService).to receive(:query).twice.with(anything, hash_including(rows: 10_000)).and_return([])
+      end
+
+      it "requests >10 rows" do
+        presenter.file_set_presenters
+      end
+    end
+
+    context "when some of the members are not file sets" do
+      let(:another_work) { create(:work) }
+
+      before do
+        obj.ordered_members << another_work
+        obj.save!
+      end
+
+      it "filters out members that are not file sets" do
+        expect(presenter.file_set_presenters.map(&:id)).not_to include another_work.id
+      end
+    end
+  end
+
+  describe "#representative_presenter" do
+    let(:obj) { create(:work_with_representative_file) }
+    let(:attributes) { obj.to_solr }
+
+    it "has a representative" do
+      expect(Hyrax::PresenterFactory).to receive(:build_for)
+        .with(ids: [obj.members[0].id],
+              presenter_class: Hyrax::CompositePresenterFactory,
+              presenter_args: [ability, request])
+        .and_return ["abc"]
+      expect(presenter.representative_presenter).to eq("abc")
+    end
+
+    context 'without a representative' do
+      let(:obj) { create(:work) }
+
+      it 'has a nil presenter' do
+        expect(presenter.representative_presenter).to be_nil
+      end
+    end
+
+    context 'when it is its own representative' do
+      let(:obj) { create(:work) }
+
+      before do
+        obj.representative_id = obj.id
+        obj.save
+      end
+
+      it 'has a nil presenter; avoids infinite loop' do
+        expect(presenter.representative_presenter).to be_nil
+      end
+    end
+  end
+
+  describe "#download_url" do
+    subject { presenter.download_url }
+
+    let(:solr_document) { SolrDocument.new(work.to_solr) }
+
+    context "with a representative" do
+      let(:work) { create(:work_with_representative_file) }
+
+      it { is_expected.to eq "http://#{request.host}/downloads/#{work.representative_id}" }
+    end
+
+    context "without a representative" do
+      let(:work) { create(:work) }
+
+      it { is_expected.to eq '' }
+    end
+  end
+
+  describe '#page_title' do
+    subject { presenter.page_title }
+
+    it { is_expected.to eq 'Generic Work | foo | ID: 888888 | Hyrax' }
+  end
+
+  describe "#valid_child_concerns" do
+    subject { presenter }
+
+    it "delegates to the class attribute of the model" do
+      allow(GenericWork).to receive(:valid_child_concerns).and_return([GenericWork])
+
+      expect(subject.valid_child_concerns).to eq [GenericWork]
+    end
+  end
+
+  describe "#attribute_to_html" do
+    let(:renderer) { double('renderer') }
+
+    context 'with an existing field' do
+      before do
+        allow(Hyrax::Renderers::AttributeRenderer).to receive(:new)
+          .with(:title, ['foo', 'bar'], {})
+          .and_return(renderer)
+      end
+
+      it "calls the AttributeRenderer" do
+        expect(renderer).to receive(:render)
+        presenter.attribute_to_html(:title)
+      end
+    end
+
+    context "with a field that doesn't exist" do
+      it "logs a warning" do
+        expect(Rails.logger).to receive(:warn).with('Hyrax::WorkShowPresenter attempted to render restrictions, but no method exists with that name.')
+        presenter.attribute_to_html(:restrictions)
+      end
+    end
+  end
+
+  context "with workflow" do
+    let(:user) { create(:user) }
+    let(:ability) { Ability.new(user) }
+    let(:entity) { instance_double(Sipity::Entity) }
+
+    describe "#workflow" do
+      subject { presenter.workflow }
+
+      it { is_expected.to be_kind_of Hyrax::WorkflowPresenter }
+    end
+  end
+
+  context "with inspect_work" do
+    let(:user) { create(:user) }
+    let(:ability) { Ability.new(user) }
+
+    describe "#inspect_work" do
+      subject { presenter.inspect_work }
+
+      it { is_expected.to be_kind_of Hyrax::InspectWorkPresenter }
+    end
+  end
+
+  describe "graph export methods" do
+    let(:graph) do
+      RDF::Graph.new.tap do |g|
+        g << [RDF::URI('http://example.com/1'), RDF::Vocab::DC.title, 'Test title']
+      end
+    end
+
+    let(:exporter) { double }
+
+    before do
+      allow(Hyrax::GraphExporter).to receive(:new).and_return(exporter)
+      allow(exporter).to receive(:fetch).and_return(graph)
+    end
+
+    describe "#export_as_nt" do
+      subject { presenter.export_as_nt }
+
+      it { is_expected.to eq "<http://example.com/1> <http://purl.org/dc/terms/title> \"Test title\" .\n" }
+    end
+
+    describe "#export_as_ttl" do
+      subject { presenter.export_as_ttl }
+
+      it { is_expected.to eq "\n<http://example.com/1> <http://purl.org/dc/terms/title> \"Test title\" .\n" }
+    end
+
+    describe "#export_as_jsonld" do
+      subject { presenter.export_as_jsonld }
+
+      it do
+        is_expected.to eq '{
+  "@context": {
+    "dc": "http://purl.org/dc/terms/"
+  },
+  "@id": "http://example.com/1",
+  "dc:title": "Test title"
+}'
+      end
+    end
+  end
+
+  describe "#manifest" do
+    let(:work) { create(:work_with_one_file) }
+    let(:solr_document) { SolrDocument.new(work.to_solr) }
+
+    describe "#sequence_rendering" do
+      subject do
+        presenter.sequence_rendering
+      end
+
+      before do
+        Hydra::Works::AddFileToFileSet.call(work.file_sets.first,
+                                            File.open(fixture_path + '/world.png'), :original_file)
+      end
+
+      it "returns a hash containing the rendering information" do
+        work.rendering_ids = [work.file_sets.first.id]
+        expect(subject).to be_an Array
+      end
+    end
+
+    describe "#manifest_metadata" do
+      subject do
+        presenter.manifest_metadata
+      end
+
+      before do
+        work.title = ['Test title', 'Another test title']
+      end
+
+      it "returns an array of metadata values" do
+        expect(subject[0]['label']).to eq('Title')
+        expect(subject[0]['value']).to include('Test title', 'Another test title')
+      end
+    end
+  end
+
+  describe "#show_deposit_for?" do
+    subject { presenter }
+
+    context "when user has depositable collections" do
+      let(:user_collections) { double }
+
+      it "returns true" do
+        expect(subject.show_deposit_for?(collections: user_collections)).to be true
+      end
+    end
+
+    context "when user does not have depositable collections" do
+      let(:user_collections) { nil }
+
+      context "and user can create a collection" do
+        before do
+          allow(ability).to receive(:can?).with(:create_any, Collection).and_return(true)
+        end
+
+        it "returns true" do
+          expect(subject.show_deposit_for?(collections: user_collections)).to be true
+        end
+      end
+
+      context "and user can NOT create a collection" do
+        before do
+          allow(ability).to receive(:can?).with(:create_any, Collection).and_return(false)
+        end
+
+        it "returns false" do
+          expect(subject.show_deposit_for?(collections: user_collections)).to be false
+        end
+      end
+    end
+  end
+
+  describe '#iiif_viewer' do
+    subject { presenter.iiif_viewer }
+
+    it 'defaults to universal viewer' do
+      expect(subject).to be :universal_viewer
+    end
+  end
+end