hyrax 3.0.0.pre.beta2 → 3.0.0.pre.beta3

data/spec/hyrax/transactions/create_work_spec.rb

@@ -83,6 +83,34 @@ RSpec.describe Hyrax::Transactions::CreateWork do
     end
   end
 
+  context 'when requesting a lease' do
+    let(:after)     { 'restricted' }
+    let(:during)    { 'open' }
+    let(:end_date)  { (Time.zone.today + 2).to_s }
+    let(:request)   { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE }
+    let(:step_args) { { apply_visibility: [visibility: request, release_date: end_date, during: during, after: after] } }
+
+    it 'sets the lease' do
+      expect { transaction.with_step_args(step_args).call(work) }
+        .to change { work.lease }
+        .to be_a_lease_matching(release_date: end_date, during: during, after: after)
+    end
+  end
+
+  context 'when requesting an embargo' do
+    let(:after)     { 'open' }
+    let(:during)    { 'restricted' }
+    let(:end_date)  { (Time.zone.today + 2).to_s }
+    let(:request)   { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO }
+    let(:step_args) { { apply_visibility: [visibility: request, release_date: end_date, during: during, after: after] } }
+
+    it 'sets the embargo' do
+      expect { transaction.with_step_args(step_args).call(work) }
+        .to change { work.embargo }
+        .to be_an_embargo_matching(release_date: end_date, during: during, after: after)
+    end
+  end
+
   context 'with an admin set' do
     let(:admin_set) { AdminSet.find(template.source_id) }
     let(:template)  { create(:permission_template, with_admin_set: true) }
@@ -152,4 +180,44 @@ RSpec.describe Hyrax::Transactions::CreateWork do
       end
     end
   end
+
+  context 'when inheriting permissions from a collection' do
+    let(:manage_groups) { ['edit_group_1', 'edit_group_2'] }
+    let(:manage_users)  { create_list(:user, 2) }
+    let(:view_groups)   { ['read_group_1', 'read_group_2'] }
+    let(:view_users)    { create_list(:user, 2) }
+    let(:collection)    { create(:collection_lw, with_permission_template: permissions) }
+    let(:step_args)     { { apply_collection_template: [collections: [collection]] } }
+
+    let(:permissions) do
+      { manage_groups: manage_groups,
+        manage_users:  manage_users,
+        view_groups:   view_groups,
+        view_users:    view_users }
+    end
+
+    it 'assigns edit groups from template' do
+      expect { transaction.with_step_args(step_args).call(work) }
+        .to change { work.edit_groups }
+        .to include(*manage_groups)
+    end
+
+    it 'assigns edit users from template' do
+      expect { transaction.with_step_args(step_args).call(work) }
+        .to change { work.edit_users }
+        .to include(*manage_users.map(&:user_key))
+    end
+
+    it 'assigns read groups from template' do
+      expect { transaction.with_step_args(step_args).call(work) }
+        .to change { work.read_groups }
+        .to include(*view_groups)
+    end
+
+    it 'assigns read users from template' do
+      expect { transaction.with_step_args(step_args).call(work) }
+        .to change { work.read_users }
+        .to include(*view_users.map(&:user_key))
+    end
+  end
 end

data/spec/hyrax/transactions/steps/apply_collection_permission_template_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'hyrax/transactions'
+
+RSpec.describe Hyrax::Transactions::Steps::ApplyCollectionPermissionTemplate do
+  subject(:step) { described_class.new }
+  let(:work)     { build(:generic_work) }
+
+  it 'is a success' do
+    expect(step.call(work)).to be_success
+  end
+
+  context 'when collection has no template' do
+    let(:collection) { double(Collection, id: 'fake_id') }
+
+    it 'is a failure' do
+      expect(step.call(work, collections: [collection])).to be_failure
+    end
+  end
+
+  context 'with permission template' do
+    let(:manage_groups) { ['edit_group_1', 'edit_group_2'] }
+    let(:manage_users)  { create_list(:user, 2) }
+    let(:view_groups)   { ['read_group_1', 'read_group_2'] }
+    let(:view_users)    { create_list(:user, 2) }
+    let(:collection)    { create(:collection_lw, with_permission_template: permissions) }
+
+    let(:permissions) do
+      { manage_groups: manage_groups,
+        manage_users:  manage_users,
+        view_groups:   view_groups,
+        view_users:    view_users }
+    end
+
+    it 'assigns edit users from template' do
+      expect { step.call(work, collections: [collection]) }
+        .to change { work.edit_users }
+        .to include(*manage_users.map(&:user_key))
+    end
+
+    it 'assigns edit groups from template' do
+      expect { step.call(work, collections: [collection]) }
+        .to change { work.edit_groups }
+        .to include(*manage_groups)
+    end
+
+    it 'assigns read users from template' do
+      expect { step.call(work, collections: [collection]) }
+        .to change { work.read_users }
+        .to include(*view_users.map(&:user_key))
+    end
+
+    it 'assigns read groups from template' do
+      expect { step.call(work, collections: [collection]) }
+        .to change { work.read_groups }
+        .to include(*view_groups)
+    end
+  end
+end

data/spec/hyrax/transactions/steps/apply_visibility_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'hyrax/transactions'
+
+RSpec.describe Hyrax::Transactions::Steps::ApplyVisibility do
+  subject(:step) { described_class.new }
+  let(:work)     { build(:generic_work) }
+
+  describe '#call' do
+    it 'is a success' do
+      expect(step.call(work)).to be_success
+    end
+
+    context 'without a visibility' do
+      it 'retains the existing visibility' do
+        expect { step.call(work) }
+          .not_to change { work.visibility }
+      end
+    end
+
+    context 'when setting visibility explictly' do
+      let(:visibility) { 'open' }
+
+      it 'applies the custom visibility embargo' do
+        expect { step.call(work, visibility: visibility) }
+          .to change { work.visibility }
+          .to visibility
+      end
+    end
+
+    context 'when setting a lease' do
+      let(:visibility) { 'lease' }
+      let(:end_date)   { (Time.zone.now + 2).to_s }
+      let(:after)      { 'restricted' }
+      let(:during)     { 'open' }
+      let(:opts) do
+        { visibility:   visibility,
+          release_date: end_date,
+          after:        after,
+          during:       during }
+      end
+
+      it 'interprets and applies the lease' do
+        expect { step.call(work, **opts) }
+          .to change { work.lease }
+          .to be_a_lease_matching(release_date: end_date, during: during, after: after)
+      end
+
+      context 'with missing end date' do
+        it 'is a failure' do
+          expect(step.call(work, visibility: visibility)).to be_failure
+        end
+      end
+    end
+
+    context 'when setting an embargo' do
+      let(:visibility) { 'embargo' }
+      let(:end_date)   { (Time.zone.now + 2).to_s }
+      let(:after)      { 'open' }
+      let(:during)     { 'restricted' }
+
+      let(:opts) do
+        { visibility:   visibility,
+          release_date: end_date,
+          after:        after,
+          during:       during }
+      end
+
+      it 'interprets and applies the embargo' do
+        expect { step.call(work, **opts) }
+          .to change { work.embargo }
+          .to be_an_embargo_matching(release_date: end_date, during: during, after: after)
+      end
+
+      context 'with missing end date' do
+        it 'is a failure' do
+          expect(step.call(work, visibility: visibility)).to be_failure
+        end
+      end
+    end
+  end
+end

data/spec/indexers/hyrax/admin_set_indexer_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Hyrax::AdminSetIndexer do
+  let(:indexer) { described_class.new(admin_set) }
+  let(:admin_set) { build(:admin_set) }
+  let(:doc) do
+    {
+      'generic_type_sim' => ['Admin Set']
+    }
+  end
+
+  describe "#generate_solr_document" do
+    it "has required fields" do
+      expect(indexer.generate_solr_document).to match a_hash_including(doc)
+    end
+  end
+end

data/spec/indexers/hyrax/file_set_indexer_spec.rb

@@ -35,10 +35,23 @@ RSpec.describe Hyrax::FileSetIndexer do
       page_count: ['1'],
       file_title: ['title'],
       duration: ['0:1'],
-      sample_rate: ['sample rate']
+      sample_rate: ['sample rate'],
+      versions: version_graph
     )
   end
 
+  let(:resource_version) do
+    ActiveFedora::VersionsGraph::ResourceVersion.new.tap do |v|
+      v.uri = "http://test.example/rest/example/foo123/files/#{mock_file.id}/fcr:versions/version1"
+      v.label = 'version1'
+      v.created = '2019-08-07T06:05:43.210Z'
+    end
+  end
+
+  let(:version_graph) do
+    ActiveFedora::VersionsGraph.new
+  end
+
   let(:mock_text) do
     mock_file_factory(content: "abcxyz")
   end
@@ -53,6 +66,7 @@ RSpec.describe Hyrax::FileSetIndexer do
       allow(Hyrax::ThumbnailPathService).to receive(:call).and_return('/downloads/foo123?file=thumbnail')
       allow(file_set).to receive(:original_file).and_return(mock_file)
       allow(file_set).to receive(:extracted_text).and_return(mock_text)
+      allow(version_graph).to receive(:fedora_versions) { [resource_version] }
     end
     subject { indexer.generate_solr_document }
 
@@ -92,6 +106,17 @@ RSpec.describe Hyrax::FileSetIndexer do
       expect(subject['file_title_tesim']).to eq ['title']
       expect(subject['duration_tesim']).to eq ['0:1']
       expect(subject['sample_rate_tesim']).to eq ['sample rate']
+      expect(subject['original_file_id_ssi']).to eq "foo123/files/#{file_set.original_file.id}/fcr:versions/version1"
+    end
+
+    context "when original_file is not versioned" do
+      before do
+        allow(version_graph).to receive(:fedora_versions).and_return([])
+      end
+
+      it "does not have version info indexed" do
+        expect(subject['original_file_id_ssi']).to eq file_set.original_file.id
+      end
     end
   end
 

data/spec/indexers/hyrax/valkyrie_indexers/base_indexer_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe Hyrax::ValkyrieIndexers::BaseIndexer do
+  let(:indexer) { described_class.new(resource: resource) }
+  let(:resource) { FactoryBot.create_for_repository(:hyrax_resource) }
+
+  describe "#to_solr" do
+    it "provides id, created_at_dtsi, and updated_at_dtsi" do
+      expect(indexer.to_solr).to match a_hash_including(
+        id: resource.id.to_s,
+        created_at_dtsi: resource.created_at,
+        updated_at_dtsi: resource.updated_at
+      )
+    end
+  end
+end

data/spec/jobs/import_url_job_spec.rb

@@ -3,10 +3,11 @@ RSpec.describe ImportUrlJob do
 
   let(:file_path) { fixture_path + '/world.png' }
   let(:file_hash) { '/673467823498723948237462429793840923582' }
+  let(:label) { file_path }
 
   let(:file_set) do
     FileSet.new(import_url: "http://example.org#{file_hash}",
-                label: file_path) do |f|
+                label: label) do |f|
       f.apply_depositor_metadata(user.user_key)
     end
   end
@@ -74,7 +75,21 @@ RSpec.describe ImportUrlJob do
 
     it 'leaves the temp directory in place' do
       described_class.perform_now(file_set, operation)
-      expect(File.exist?(File.join(tmpdir, file_hash))).to be true
+      file_name = File.basename(file_set.label)
+      expect(File.exist?(File.join(tmpdir, file_name))).to be true
+    end
+
+    context 'when the FileSet has an existing label' do
+      let(:label) { "example.tif" }
+      before do
+        allow(Rails.logger).to receive(:debug)
+      end
+      it 'uses the FileSet label' do
+        described_class.perform_now(file_set, operation)
+        tmp_file_path = Rails.root.join(tmpdir, label)
+        expect(Rails.logger).to have_received(:debug).with("ImportUrlJob: Closing #{tmp_file_path}")
+        expect(File.exist?(tmp_file_path.to_s)).to be true
+      end
     end
   end
 
@@ -130,4 +145,36 @@ RSpec.describe ImportUrlJob do
       expect(last_message.body).to eq("Error: Timeout")
     end
   end
+
+  context 'when the URL to the remote file has headers' do
+    let(:import_url) { "http://example.org#{file_hash}" }
+    let(:headers) do
+      {
+        "Authorization" => "OAuth <ACCESS_TOKEN>"
+      }
+    end
+    let(:file_set) do
+      FileSet.new(import_url: import_url, label: file_path) do |f|
+        f.apply_depositor_metadata(user.user_key)
+      end
+    end
+    let(:operation) { create(:operation) }
+    let(:import_uri) { URI(import_url) }
+
+    before do
+      allow(BrowseEverything::Retriever).to receive(:can_retrieve?).and_return(true)
+      described_class.perform_now(file_set, operation, headers)
+    end
+
+    it 'submits a request to the cloud server with auth headers' do
+      expect(BrowseEverything::Retriever).to have_received(:can_retrieve?).with(import_uri, headers)
+    end
+
+    it 'retrieves the cloud server resources with the auth headers' do
+      expect(mock_retriever).to have_received(:retrieve).with(
+        "url" => import_uri,
+        "headers" => headers
+      )
+    end
+  end
 end

data/spec/jobs/ingest_local_file_job_spec.rb

@@ -3,6 +3,9 @@ RSpec.describe IngestLocalFileJob do
 
   let(:file_set) { FileSet.new }
   let(:actor) { double }
+  let(:path) do
+    File.join(fixture_path, 'world.png')
+  end
 
   before do
     allow(Hyrax::Actors::FileSetActor).to receive(:new).with(file_set, user).and_return(actor)
@@ -11,6 +14,27 @@ RSpec.describe IngestLocalFileJob do
   it 'has attached a file' do
     expect(FileUtils).not_to receive(:rm)
     expect(actor).to receive(:create_content).and_return(true)
-    described_class.perform_now(file_set, File.join(fixture_path, 'world.png'), user)
+    described_class.perform_now(file_set, path, user)
+  end
+
+  context 'when an error is encountered when trying to save the file to disk' do
+    let(:callback) do
+      instance_double(Hyrax::Callbacks::Registry)
+    end
+    let(:config) do
+      instance_double(Hyrax::Configuration)
+    end
+
+    before do
+      allow(callback).to receive(:run)
+      allow(config).to receive(:callback).and_return(callback)
+      allow(Hyrax).to receive(:config).and_return(config)
+      allow(actor).to receive(:create_content).and_raise(SystemCallError, "example file system error")
+      described_class.perform_now(file_set, path, user)
+    end
+
+    it "invokes the file failure callback" do
+      expect(callback).to have_received(:run).with(:after_import_local_file_failure, file_set, user, path)
+    end
   end
 end

data/spec/jobs/visibility_copy_job_spec.rb

@@ -1,4 +1,50 @@
+# frozen_string_literal: true
+
 RSpec.describe VisibilityCopyJob do
+  context 'context with a valkyrie resource' do
+    let(:proxy)    { Hyrax::ActiveJobProxy.new(resource: resource) }
+    let(:resource) { FactoryBot.create(:work_with_files).valkyrie_resource }
+    let(:queries)  { Hyrax.query_service.custom_queries }
+
+    it 'serializes proxies' do
+      expect { described_class.perform_later(proxy) }.not_to raise_error
+    end
+
+    it 'copies visibility to file sets' do
+      resource.visibility = 'open'
+
+      expect { described_class.perform_now(resource) }
+        .to change { queries.find_child_filesets(resource: resource).map(&:visibility) }
+        .to ['open', 'open']
+    end
+
+    context 'with an embargo' do
+      let(:resource) { FactoryBot.create(:embargoed_work_with_files).valkyrie_resource }
+
+      it 'applies a copy of the embargo' do
+        release_date = resource.embargo.embargo_release_date
+
+        expect { described_class.perform_now(resource) }
+          .to change { queries.find_child_filesets(resource: resource).map(&:embargo) }
+          .to contain_exactly(have_attributes(embargo_release_date: release_date),
+                              have_attributes(embargo_release_date: release_date))
+      end
+    end
+
+    context 'when work is under lease' do
+      let(:resource) { FactoryBot.create(:leased_work_with_files).valkyrie_resource }
+
+      it 'applies a copy of the embargo' do
+        release_date = resource.lease.lease_expiration_date
+
+        expect { described_class.perform_now(resource) }
+          .to change { queries.find_child_filesets(resource: resource).map(&:lease) }
+          .to contain_exactly(have_attributes(lease_expiration_date: release_date),
+                              have_attributes(lease_expiration_date: release_date))
+      end
+    end
+  end
+
   describe 'an open access work' do
     let(:work) { create(:work_with_files) }