test_hyrax 0.0.1.alpha

data/spec/presenters/hyrax/lease_presenter_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+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/permission_badge_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Hyrax::PermissionBadge do
+  let(:badge) { described_class.new(solr_doc) }
+  let(:solr_doc) { SolrDocument.new(attributes) }
+  let(:attributes) { {} }
+
+  describe "#render" do
+    subject { badge.render }
+    context "when open-access with embargo" do
+      let(:attributes) { { read_access_group_ssim: ['public'], embargo_release_date_dtsi: '2016-05-04' } }
+      it { is_expected.to eq "<span title=\"Open Access with Embargo\" class=\"label label-warning\">Open Access with Embargo</span>" }
+    end
+
+    context "when open-access" do
+      let(:attributes) { { read_access_group_ssim: ['public'] } }
+      it { is_expected.to eq "<span title=\"Open Access\" class=\"label label-success\">Open Access</span>" }
+    end
+
+    context "when registered" do
+      let(:attributes) { { read_access_group_ssim: ['registered'] } }
+      it { is_expected.to eq "<span title=\"Institution Name\" class=\"label label-info\">Institution Name</span>" }
+    end
+
+    context "when private" do
+      it { is_expected.to eq "<span title=\"Private\" class=\"label label-danger\">Private</span>" }
+    end
+  end
+end

data/spec/presenters/hyrax/presenter_factory_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Hyrax::PresenterFactory do
+  describe "#build_presenters" 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_presenters(['12', '13'], presenter_class, 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_presenters(['12', '13'],
+                                         presenter_class,
+                                         '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,26 @@
+describe Hyrax::PresenterRenderer, type: :view do
+  let(:work) { GenericWork.new }
+  let(:ability) { double }
+  let(:document) { SolrDocument.new(work.to_solr) }
+  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_type_list_presenter_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+# Note: test app generates multiple work types (concerns) now
+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
+end

data/spec/presenters/hyrax/select_type_presenter_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+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
+end

data/spec/presenters/hyrax/single_use_link_presenter_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+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.downloadKey.first(6)) }
+    end
+
+    describe "delegated methods" do
+      its(:downloadKey) { is_expected.to eq(link.downloadKey) }
+      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/trophy_presenter_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe Hyrax::TrophyPresenter do
+  describe "find_by_user" do
+    let(:user) { create(:user) }
+    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) }
+
+    subject { described_class.find_by_user(user) }
+    it "returns a list of generic works" do
+      expect(subject.size).to eq 3
+      expect(subject).to all(be_kind_of described_class)
+    end
+  end
+
+  let(:presenter) { described_class.new(solr_document) }
+  let(:solr_document) { SolrDocument.new(id: '123456', has_model_ssim: 'GenericWork', title_tesim: ['A Title']) }
+
+  describe "id" do
+    subject { presenter.id }
+    it { is_expected.to eq '123456' }
+  end
+
+  describe "to_param" do
+    subject { presenter.to_param }
+    it { is_expected.to eq '123456' }
+  end
+
+  describe "model_name" do
+    subject { presenter.model_name }
+    it { is_expected.to eq GenericWork.model_name }
+  end
+
+  describe 'thumbnail_path' do
+    let(:solr_document) { SolrDocument.new(thumbnail_path_ss: '/foo/bar.png') }
+    subject { presenter.thumbnail_path }
+    it { is_expected.to eq '/foo/bar.png' }
+  end
+
+  describe '#to_s' do
+    subject { presenter.to_s }
+    it { is_expected.to eq("A Title") }
+  end
+end

data/spec/presenters/hyrax/user_profile_presenter_spec.rb

@@ -0,0 +1,26 @@
+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,32 @@
+require 'spec_helper'
+
+describe Hyrax::VersionListPresenter, :no_clean 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,54 @@
+require 'spec_helper'
+
+describe Hyrax::VersionPresenter, :no_clean 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,287 @@
+describe Hyrax::WorkShowPresenter do
+  let(:solr_document) { SolrDocument.new(attributes) }
+  let(:request) { double }
+
+  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'] }
+  end
+  let(:ability) { nil }
+  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(:based_near).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) }
+
+  describe "#model_name" do
+    subject { presenter.model_name }
+    it { is_expected.to be_kind_of ActiveModel::Name }
+  end
+
+  describe '#stats_path' do
+    let(:user) { 'sarah' }
+    let(:ability) { double "Ability" }
+    let(:work) { build(:generic_work, id: '123abc') }
+    let(:attributes) { work.to_solr }
+    it { expect(presenter.stats_path).to eq Hyrax::Engine.routes.url_helpers.stats_work_path(id: work) }
+  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 "#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 "#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
+
+    describe "getting presenters from factory" do
+      let(:attributes) { {} }
+      let(:presenter_class) { double }
+      before do
+        allow(presenter).to receive(:composite_presenter_class).and_return(presenter_class)
+        allow(presenter).to receive(:ordered_ids).and_return(['12', '33'])
+        allow(presenter).to receive(:file_set_ids).and_return(['33', '12'])
+      end
+
+      it "uses the set class" do
+        expect(Hyrax::PresenterFactory).to receive(:build_presenters)
+          .with(['12', '33'], presenter_class, ability, request)
+        presenter.file_set_presenters
+      end
+    end
+  end
+
+  describe "#representative_presenter" do
+    let(:obj) { create(:work_with_representative_file) }
+    let(:attributes) { obj.to_solr }
+    let(:presenter_class) { double }
+    before do
+      allow(presenter).to receive(:composite_presenter_class).and_return(presenter_class)
+    end
+    it "has a representative" do
+      expect(Hyrax::PresenterFactory).to receive(:build_presenters)
+        .with([obj.members[0].id], presenter_class, ability, request).and_return ["abc"]
+      expect(presenter.representative_presenter).to eq("abc")
+    end
+  end
+
+  describe '#page_title' do
+    subject { presenter.page_title }
+    it { is_expected.to eq 'foo' }
+  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
+end