hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/jobs/import_export_job_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+RSpec.describe ImportExportJob do
+  let(:work)    { create(:work) }
+  let(:job)     { described_class.new }
+
+  describe "when exporting" do
+    let(:command) do
+      "java -jar tmp/fcrepo-import-export.jar --mode export --resource #{work.uri} --dir tmp/descriptions"
+    end
+
+    it "runs the export command" do
+      expect(job).to receive(:internal_call).with(command)
+      job.perform(resource: work.uri.to_s)
+    end
+  end
+
+  describe "when importing" do
+    let(:command) do
+      "java -jar tmp/fcrepo-import-export.jar --mode import --resource #{work.uri} --dir tmp/descriptions"
+    end
+
+    it "runs the import command" do
+      expect(job).to receive(:internal_call).with(command)
+      job.perform(resource: work.uri.to_s, mode: "import")
+    end
+  end
+end

data/spec/jobs/import_url_job_spec.rb

@@ -0,0 +1,133 @@
+RSpec.describe ImportUrlJob do
+  let(:user) { create(:user) }
+
+  let(:file_path) { fixture_path + '/world.png' }
+  let(:file_hash) { '/673467823498723948237462429793840923582' }
+
+  let(:file_set) do
+    FileSet.new(import_url: "http://example.org#{file_hash}",
+                label: file_path) do |f|
+      f.apply_depositor_metadata(user.user_key)
+    end
+  end
+
+  let(:operation) { create(:operation) }
+  let(:actor) { instance_double(Hyrax::Actors::FileSetActor, create_content: true) }
+
+  let(:mock_retriever) { double }
+  let(:inbox) { user.mailbox.inbox }
+
+  before do
+    allow(Hyrax::Actors::FileSetActor).to receive(:new).with(file_set, user).and_return(actor)
+
+    response_headers = {
+      'Content-Type' => 'image/png',
+      'Content-Length' => 1,
+      'Content-Range' => "0-0/#{File.size(File.expand_path(file_path, __FILE__))}"
+    }
+
+    stub_request(:get, "http://example.org#{file_hash}").with(headers: { 'Range' => 'bytes=0-0' }).to_return(
+      body: File.open(File.expand_path(file_path, __FILE__)).read(1), status: 206, headers: response_headers
+    )
+
+    stub_request(:get, "http://example.org#{file_hash}").to_return(
+      body: File.open(File.expand_path(file_path, __FILE__)).read, status: 200, headers: response_headers
+    )
+
+    allow(BrowseEverything::Retriever).to receive(:new).and_return(mock_retriever)
+    allow(mock_retriever).to receive(:retrieve)
+  end
+
+  context 'before enqueueing the job' do
+    before do
+      file_set.id = 'fsid123'
+    end
+
+    describe '.operation' do
+      it 'fetches the operation' do
+        described_class.perform_later(file_set, operation)
+        expect { subject.operation.to eq Hyrax::Operation }
+      end
+    end
+  end
+
+  context 'after running the job' do
+    let!(:tmpdir) { Rails.root.join("tmp/spec/#{Process.pid}") }
+
+    before do
+      file_set.id = 'abc123'
+      allow(file_set).to receive(:reload)
+
+      FileUtils.mkdir_p(tmpdir)
+      allow(Dir).to receive(:mktmpdir).and_return(tmpdir)
+    end
+
+    after do
+      FileUtils.remove_entry(tmpdir)
+    end
+
+    it 'creates the content and updates the associated operation' do
+      expect(actor).to receive(:create_content).with(File, from_url: true).and_return(true)
+      described_class.perform_now(file_set, operation)
+      expect(operation).to be_success
+    end
+
+    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
+    end
+  end
+
+  context "when a batch update job is running too" do
+    let(:title) { { file_set.id => ['File One'] } }
+    let(:file_set_id) { file_set.id }
+
+    before do
+      file_set.save!
+      allow(ActiveFedora::Base).to receive(:find).and_call_original
+      allow(ActiveFedora::Base).to receive(:find).with(file_set_id).and_return(file_set)
+      # run the batch job to set the title
+      file_set.update(title: ['File One'])
+    end
+
+    it "does not kill all the metadata set by other processes" do
+      # run the import job
+      described_class.perform_now(file_set, operation)
+      # import job should not override the title set another process
+      file = FileSet.find(file_set_id)
+      expect(file.title).to eq(['File One'])
+    end
+  end
+
+  context 'when the remote file is unavailable' do
+    before do
+      stub_request(:get, "http://example.org#{file_hash}").with(headers: { 'Range' => 'bytes=0-0' }).to_return(
+        body: '', status: 406, headers: {}
+      )
+    end
+
+    it 'sends error message' do
+      expect(operation).to receive(:fail!)
+      expect(file_set.original_file).to be_nil
+      described_class.perform_now(file_set, operation)
+      expect(inbox.count).to eq(1)
+      last_message = inbox[0].last_message
+      expect(last_message.subject).to eq('File Import Error')
+      expect(last_message.body).to eq("Error: Expired URL")
+    end
+  end
+
+  context 'when retrieval fails' do
+    before { allow(mock_retriever).to receive(:retrieve).and_raise(StandardError, 'Timeout') }
+
+    it 'sends error message' do
+      expect(operation).to receive(:fail!)
+      expect(file_set.original_file).to be_nil
+      described_class.perform_now(file_set, operation)
+      expect(inbox.count).to eq(1)
+      last_message = inbox[0].last_message
+      expect(last_message.subject).to eq('File Import Error')
+      expect(last_message.body).to eq("Error: Timeout")
+    end
+  end
+end

data/spec/jobs/ingest_local_file_job_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe IngestLocalFileJob do
+  let(:user) { create(:user) }
+
+  let(:file_set) { FileSet.new }
+  let(:actor) { double }
+
+  before do
+    allow(Hyrax::Actors::FileSetActor).to receive(:new).with(file_set, user).and_return(actor)
+  end
+
+  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)
+  end
+end

data/spec/jobs/inherit_permissions_job_spec.rb

@@ -0,0 +1,94 @@
+RSpec.describe InheritPermissionsJob do
+  let(:user) { create(:user) }
+  let(:work) { create(:work_with_one_file, user: user) }
+
+  before do
+    work.permissions.build(name: name, type: type, access: access)
+    work.save
+  end
+
+  context "when edit people change" do
+    let(:name) { 'abc@123.com' }
+    let(:type) { 'person' }
+    let(:access) { 'edit' }
+
+    it 'copies permissions to its contained files' do
+      # files have the depositor as the edit user to begin with
+      expect(work.file_sets.first.edit_users).to eq [user.to_s]
+
+      described_class.perform_now(work)
+      work.reload.file_sets.each do |file|
+        expect(file.edit_users).to match_array [user.to_s, "abc@123.com"]
+      end
+    end
+
+    context "when people should be removed" do
+      before do
+        file_set = work.file_sets.first
+        file_set.permissions.build(name: "remove_me", type: type, access: access)
+        file_set.save
+      end
+
+      it 'copies permissions to its contained files' do
+        # files have the depositor as the edit user to begin with
+        expect(work.file_sets.first.edit_users).to eq [user.to_s, "remove_me"]
+
+        described_class.perform_now(work)
+        work.reload.file_sets.each do |file|
+          expect(file.edit_users).to match_array [user.to_s, "abc@123.com"]
+        end
+      end
+    end
+  end
+
+  context "when read people change" do
+    let(:name) { 'abc@123.com' }
+    let(:type) { 'person' }
+    let(:access) { 'read' }
+
+    it 'copies permissions to its contained files' do
+      # files have the depositor as the edit user to begin with
+      expect(work.file_sets.first.read_users).to eq []
+
+      described_class.perform_now(work)
+      work.reload.file_sets.each do |file|
+        expect(file.read_users).to match_array ["abc@123.com"]
+        expect(file.edit_users).to match_array [user.to_s]
+      end
+    end
+  end
+
+  context "when read groups change" do
+    let(:name) { 'my_read_group' }
+    let(:type) { 'group' }
+    let(:access) { 'read' }
+
+    it 'copies permissions to its contained files' do
+      # files have the depositor as the edit user to begin with
+      expect(work.file_sets.first.read_groups).to eq []
+
+      described_class.perform_now(work)
+      work.reload.file_sets.each do |file|
+        expect(file.read_groups).to match_array ["my_read_group"]
+        expect(file.edit_users).to match_array [user.to_s]
+      end
+    end
+  end
+
+  context "when edit groups change" do
+    let(:name) { 'my_edit_group' }
+    let(:type) { 'group' }
+    let(:access) { 'edit' }
+
+    it 'copies permissions to its contained files' do
+      # files have the depositor as the edit user to begin with
+      expect(work.file_sets.first.read_groups).to eq []
+
+      described_class.perform_now(work)
+      work.reload.file_sets.each do |file|
+        expect(file.edit_groups).to match_array ["my_edit_group"]
+        expect(file.edit_users).to match_array [user.to_s]
+      end
+    end
+  end
+end

data/spec/jobs/stream_notifications_job_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe StreamNotificationsJob do
+  let(:realtime_notifications) { true }
+
+  before do
+    allow(Hyrax.config).to receive(:realtime_notifications?).and_return(realtime_notifications)
+  end
+
+  describe '#perform' do
+    context 'with zero users' do
+      let(:users) { nil }
+
+      it 'does not broadcast' do
+        expect(Hyrax::NotificationsChannel).not_to receive(:broadcast_to)
+        described_class.perform_now(users)
+      end
+    end
+
+    context 'with a user' do
+      let(:users) { create(:user) }
+      let(:mailbox) { double('mailbox', unread_count: 7, label: "You've got mail!") }
+
+      before do
+        allow(UserMailbox).to receive(:new).and_return(mailbox)
+      end
+
+      it 'broadcasts to the user' do
+        expect(Hyrax::NotificationsChannel).to receive(:broadcast_to)
+          .once
+          .with(users,
+                notifications_count: 7,
+                notifications_label: "You've got mail!")
+        described_class.perform_now(users)
+      end
+
+      context 'when realtime notifications feature is disabled' do
+        let(:realtime_notifications) { false }
+
+        it 'does not broadcast' do
+          expect(Hyrax::NotificationsChannel).not_to receive(:broadcast_to)
+          described_class.perform_now(users)
+        end
+      end
+    end
+  end
+end

data/spec/jobs/user_edit_profile_event_job_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe UserEditProfileEventJob do
+  let(:user) { create(:user) }
+  let(:mock_time) { Time.zone.at(1) }
+  let(:event) { { action: "User <a href=\"/users/#{user.to_param}\">#{user.user_key}</a> has edited their profile", timestamp: '1' } }
+
+  before do
+    allow(Time).to receive(:now).at_least(:once).and_return(mock_time)
+  end
+
+  it "logs the event to the editor's dashboards" do
+    expect do
+      described_class.perform_now(user)
+    end.to change { user.events.length }.by(1)
+
+    expect(user.events.first).to eq(event)
+  end
+end

data/spec/jobs/visibility_copy_job_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe VisibilityCopyJob do
+  describe 'an open access work' do
+    let(:work) { create(:work_with_files) }
+
+    it 'copies visibility to its contained files' do
+      # files are private at the outset
+      expect(work.file_sets.first.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+
+      work.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      work.save
+      described_class.perform_now(work)
+      work.reload.file_sets.each do |file|
+        expect(file.visibility).to eq 'open'
+      end
+    end
+  end
+
+  describe 'an embargoed work' do
+    let(:work) { create(:embargoed_work_with_files) }
+    let(:file) { work.file_sets.first }
+
+    before do
+      expect(work.visibility).to eq 'restricted'
+      expect(work).to be_under_embargo
+      expect(work.file_sets.first).not_to be_under_embargo
+      described_class.perform_now(work)
+      work.reload
+    end
+
+    it 'copies visibility to its contained files and apply a copy of the embargo to the files' do
+      expect(file).to be_under_embargo
+      expect(file.embargo.id).not_to eq work.embargo.id
+    end
+  end
+
+  describe 'an leased work' do
+    let(:work) { create(:leased_work_with_files) }
+    let(:file) { work.file_sets.first }
+
+    before do
+      expect(work.visibility).to eq 'open'
+      expect(work).to be_active_lease
+      expect(work.file_sets.first).not_to be_active_lease
+      described_class.perform_now(work)
+      work.reload
+    end
+
+    it 'copies visibility to its contained files and apply a copy of the lease to the files' do
+      expect(file).to be_active_lease
+      expect(file.lease.id).not_to eq work.lease.id
+    end
+  end
+end

data/spec/lib/hyrax/analytics_spec.rb

@@ -0,0 +1,65 @@
+RSpec.describe Hyrax::Analytics do
+  before do
+    described_class.send(:remove_instance_variable, :@config) if described_class.send(:instance_variable_defined?, :@config)
+  end
+
+  describe "configuration" do
+    let(:config) { described_class.send(:config) }
+
+    context "When the yaml file has values" do
+      it "is valid" do
+        expect(config).to be_valid
+      end
+
+      it 'reads its config from a yaml file' do
+        expect(config.app_name).to eql 'My App Name'
+        expect(config.app_version).to eql '0.0.1'
+        expect(config.privkey_path).to eql '/tmp/privkey.p12'
+        expect(config.privkey_secret).to eql 's00pers3kr1t'
+        expect(config.client_email).to eql 'oauth@example.org'
+      end
+    end
+
+    context "When the yaml file has no values" do
+      before do
+        allow(File).to receive(:read).and_return("# Just comments\n# and comments\n")
+      end
+
+      it "is not valid" do
+        expect(Rails.logger).to receive(:error)
+          .with(starting_with("Unable to fetch any keys from"))
+        expect(config).not_to be_valid
+      end
+    end
+  end
+
+  describe "#user" do
+    before do
+      token = OAuth2::AccessToken.new(nil, nil)
+      allow(subject).to receive(:token).and_return(token)
+    end
+    it 'instantiates a user' do
+      expect(subject.send(:user)).to be_a(Legato::User)
+    end
+  end
+
+  describe "#profile" do
+    subject { described_class.profile }
+
+    context "when the private key file is missing" do
+      it "raises an error" do
+        expect { subject }.to raise_error RuntimeError, "Private key file for Google analytics was expected at '/tmp/privkey.p12', but no file was found."
+      end
+    end
+
+    context "when the config is not valid" do
+      before do
+        allow(File).to receive(:read).and_return("# Just comments\n# and comments\n")
+      end
+
+      it "returns nil" do
+        expect(subject).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/hyrax/arkivo/actor_spec.rb

@@ -0,0 +1,78 @@
+RSpec.describe Hyrax::Arkivo::Actor do
+  before do
+    # Don't test characterization on these items; it breaks TravisCI and it's slow
+    allow(CharacterizeJob).to receive(:perform_later)
+    allow(Hyrax::CurationConcern).to receive(:actor).and_return(work_actor)
+    allow(Hyrax::Actors::FileSetActor).to receive(:new).and_return(file_actor)
+  end
+
+  subject { described_class.new(user, item) }
+
+  let(:user) { create(:user) }
+  let(:item) { JSON.parse(FactoryBot.json(:post_item)) }
+  let(:work_actor) { instance_double(Hyrax::Actors::TransactionalRequest) }
+  let(:file_actor) { double }
+
+  describe 'Tempfile monkey-patches' do
+    subject { Tempfile.new('foo') }
+
+    it { is_expected.to respond_to(:original_filename) }
+    it { is_expected.to respond_to(:original_filename=) }
+    it { is_expected.to respond_to(:content_type) }
+    it { is_expected.to respond_to(:content_type=) }
+  end
+
+  describe '#create_work_from_item' do
+    it 'creates a work and a file and returns a GenericWork' do
+      expect(work_actor).to receive(:create).with(Hyrax::Actors::Environment) do |env|
+        expect(env.attributes).to include(arkivo_checksum: item['file']['md5'],
+                                          "title" => [item['metadata']['title']])
+      end.and_return(true)
+
+      expect(file_actor).to receive(:create_metadata)
+      expect(file_actor).to receive(:create_content) do |tmpfile|
+        expect(tmpfile).to be_instance_of Tempfile
+        expect(tmpfile.read).to eq "arkivo\n"
+      end
+      expect(file_actor).to receive(:attach_to_work)
+
+      expect(subject.create_work_from_item).to be_instance_of(GenericWork)
+    end
+  end
+
+  describe '#update_work_from_item' do
+    let(:item) { JSON.parse(FactoryBot.json(:put_item)) }
+    let(:title) { ['ZZZZZ'] }
+    let(:description) { ['This is rather lengthy.'] }
+    let(:checksum) { 'abc123' }
+    let(:work) do
+      GenericWork.new(title: title, description: description) do |f|
+        f.apply_depositor_metadata(user.user_key)
+        f.arkivo_checksum = checksum
+      end
+    end
+
+    it 'changes the title and clears other metadata' do
+      expect(work_actor).to receive(:update).with(Hyrax::Actors::Environment) do |env|
+        expect(env.attributes).to include(arkivo_checksum: item['file']['md5'],
+                                          "description" => [],
+                                          "title" => [item['metadata']['title']])
+      end.and_return(true)
+
+      expect(file_actor).to receive(:update_content) do |tmpfile|
+        expect(tmpfile).to be_instance_of Tempfile
+        expect(tmpfile.read).to eq "# HEADER\n\nThis is a paragraph!\n"
+      end
+      expect(subject.update_work_from_item(work)).to be_instance_of(GenericWork)
+    end
+  end
+
+  describe '#destroy_work' do
+    let(:work) { mock_model(GenericWork) }
+
+    it 'deletes the file' do
+      expect(work).to receive(:destroy)
+      subject.destroy_work(work)
+    end
+  end
+end

data/spec/lib/hyrax/arkivo/create_subscription_job_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe Hyrax::Arkivo::CreateSubscriptionJob do
+  let(:user) { create(:user) }
+
+  context 'with a bogus user' do
+    before { allow(User).to receive(:find_by_user_key) { nil } }
+    it 'raises because user not found' do
+      expect { described_class.perform_now(user.user_key) }.to raise_error(Hyrax::Arkivo::SubscriptionError, 'User not found')
+    end
+  end
+
+  context 'without an arkivo token' do
+    before { allow_any_instance_of(User).to receive(:arkivo_token) { nil } }
+    it 'raises because user lacks arkivo token' do
+      expect { described_class.perform_now(user.user_key) }.to raise_error(Hyrax::Arkivo::SubscriptionError, 'User does not have an Arkivo token')
+    end
+  end
+
+  context 'without a zotero userid' do
+    it 'raises because user did not oauth' do
+      expect { described_class.perform_now(user.user_key) }.to raise_error(Hyrax::Arkivo::SubscriptionError, 'User has not yet connected with Zotero')
+    end
+  end
+
+  context 'with an existing subscription' do
+    before do
+      allow_any_instance_of(User).to receive(:zotero_userid) { '45352' }
+      allow_any_instance_of(User).to receive(:arkivo_subscription) { 'http://localhost/foo/bar' }
+    end
+
+    it 'raises because user already has subscription' do
+      expect { described_class.perform_now(user.user_key) }.to raise_error(Hyrax::Arkivo::SubscriptionError, 'User already has a subscription')
+    end
+  end
+
+  context 'when expected to succeed' do
+    before do
+      allow_any_instance_of(User).to receive(:zotero_userid) { '45352' }
+      allow_any_instance_of(described_class).to receive(:post_to_api) { response }
+    end
+
+    let(:response) { double('response', headers: { 'Location' => subscription_uri }) }
+    let(:subscription_uri) { '/api/subscription/abcxyz1234' }
+
+    it 'stores a subscription URL for possible later invalidation' do
+      expect(user.arkivo_subscription).to be_blank
+      described_class.perform_now(user.user_key)
+      expect(user.reload.arkivo_subscription).to eq subscription_uri
+    end
+  end
+end

data/spec/lib/hyrax/arkivo/metadata_munger_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe Hyrax::Arkivo::MetadataMunger do
+  subject { described_class.new(metadata) }
+
+  let(:metadata) { JSON.parse(FactoryBot.json(:post_item))['metadata'] }
+
+  it 'makes camelCase symbols into underscored strings' do
+    expect(metadata).to include('resourceType', 'dateCreated', 'basedNear')
+    munged = subject.call
+    expect(munged).not_to include('resourceType', 'dateCreated', 'basedNear')
+    expect(munged).to include('resource_type', 'date_created', 'based_near')
+  end
+
+  it 'replaces url with related_url' do
+    expect(metadata).to include('url')
+    munged = subject.call
+    expect(munged).not_to include('url')
+    expect(munged).to include('related_url')
+  end
+
+  it 'replaces tags with keyword05' do
+    expect(metadata).to include('tags')
+    munged = subject.call
+    expect(munged).not_to include('tags')
+    expect(munged).to include('keyword')
+  end
+
+  it 'replaces firstName and lastName with name' do
+    expect(name_parts(metadata['creators']).count).to eq 4
+    subject.call
+    expect(name_parts(metadata['creators']).count).to eq 0
+    expect(metadata['creators'].map { |c| c['name'] }.compact.count).to eq 4
+  end
+
+  it 'segregates creators and contributors' do
+  end
+
+  it 'deletes the original creators array' do
+    expect(metadata['creators']).not_to be_nil
+    munged = subject.call
+    expect(munged['creators']).to be_nil
+  end
+
+  def name_parts(creators)
+    creators.map { |c| c['firstName'] }.compact + creators.map { |c| c['lastName'] }.compact
+  end
+end