hyrax 2.6.0 → 2.9.0

data/spec/jobs/ingest_local_file_job_spec.rb

@@ -1,40 +0,0 @@
-RSpec.describe IngestLocalFileJob do
-  let(:user) { create(:user) }
-
-  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)
-  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, 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/inherit_permissions_job_spec.rb

@@ -1,94 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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