hyrax 2.6.0 → 2.9.0

data/spec/models/hyrax/permissions/readable_permissions_spec.rb

@@ -1,52 +0,0 @@
-RSpec.describe Hyrax::Permissions::Readable do
-  class SubjectClass
-    include Hyrax::Permissions::Readable
-    attr_accessor :read_groups
-  end
-  let(:subject) { SubjectClass.new }
-
-  describe '#public?' do
-    it 'returns true for public items' do
-      subject.read_groups = %w[public othergroup]
-      expect(subject).to be_public
-    end
-    it 'returns fale for non-public items' do
-      subject.read_groups = %w[notpublic othergroup]
-      expect(subject).not_to be_public
-    end
-  end
-
-  describe '#registered?' do
-    it 'returns true for registered items' do
-      subject.read_groups = %w[registered othergroup]
-      expect(subject).to be_registered
-    end
-    it 'returns fale for non-registered items' do
-      subject.read_groups = ['othergroup']
-      expect(subject).not_to be_registered
-    end
-  end
-
-  describe '#private?' do
-    context 'is true' do
-      specify 'when there are no groups defined' do
-        subject.read_groups = []
-        expect(subject).to be_private
-      end
-      specify "when groups do not include 'public' or 'registered'" do
-        subject.read_groups = ['othergroup']
-        expect(subject).to be_private
-      end
-    end
-    context 'is false' do
-      specify "when 'registered' group is present" do
-        subject.read_groups = ['registered']
-        expect(subject).not_to be_private
-      end
-      specify "when 'public' group is present" do
-        subject.read_groups = ['public']
-        expect(subject).not_to be_private
-      end
-    end
-  end
-end

data/spec/models/hyrax/permissions/writable_permissions_spec.rb

@@ -1,12 +0,0 @@
-RSpec.describe Hyrax::Permissions::Writable do
-  class SampleModel < ActiveFedora::Base
-    include Hyrax::Permissions::Writable
-  end
-  let(:subject) { SampleModel.new }
-
-  describe '#permissions' do
-    it 'initializes with nothing specified' do
-      expect(subject.permissions).to be_empty
-    end
-  end
-end

data/spec/models/hyrax/uploaded_file_spec.rb

@@ -1,10 +0,0 @@
-RSpec.describe Hyrax::UploadedFile do
-  let(:file1) { File.open(fixture_path + '/world.png') }
-
-  subject { described_class.create(file: file1) }
-
-  it "is not in the public directory" do
-    temp_dir = Rails.root + 'tmp'
-    expect(subject.file.path).to start_with temp_dir.to_s
-  end
-end

data/spec/models/hyrax/user_usage_stats_spec.rb

@@ -1,43 +0,0 @@
-RSpec.describe Hyrax::UserUsageStats do
-  subject { create(:user) }
-
-  describe 'with cached stats' do
-    let!(:stat_1_day_ago) { UserStat.create!(user_id: subject.id, date: 1.day.ago, file_views: 3, file_downloads: 2, work_views: 5) }
-    let!(:stat_2_days_ago) { UserStat.create!(user_id: subject.id, date: 2.days.ago, file_views: 2, file_downloads: 1, work_views: 7) }
-
-    let!(:someone_elses_user_id) { subject.id + 1 }
-    let!(:not_my_stat) { UserStat.create!(user_id: someone_elses_user_id, date: 2.days.ago, file_views: 10, file_downloads: 11) }
-
-    describe '#total_file_views' do
-      it 'returns the total file views for that user' do
-        expect(subject.total_file_views).to eq 5
-      end
-    end
-
-    describe '#total_file_downloads' do
-      it 'returns the total file downloads for that user' do
-        expect(subject.total_file_downloads).to eq 3
-      end
-    end
-
-    describe '#total_work_views' do
-      it 'returns the total work views for that user' do
-        expect(subject.total_work_views).to eq 12
-      end
-    end
-  end
-
-  describe 'with empty cache' do
-    describe '#total_file_views' do
-      it 'returns the total file views for that user' do
-        expect(subject.total_file_views).to eq 0
-      end
-    end
-
-    describe '#total_file_downloads' do
-      it 'returns the total file downloads for that user' do
-        expect(subject.total_file_downloads).to eq 0
-      end
-    end
-  end
-end

data/spec/models/hyrax/work_behavior_spec.rb

@@ -1,64 +0,0 @@
-RSpec.describe Hyrax::WorkBehavior do
-  before do
-    class EssentialWork < ActiveFedora::Base
-      include Hyrax::WorkBehavior
-    end
-  end
-  after do
-    Object.send(:remove_const, :EssentialWork)
-  end
-
-  subject { EssentialWork.new }
-
-  it 'mixes together all the goodness' do
-    expect(subject.class.ancestors).to include(::Hyrax::WithFileSets,
-                                               ::Hyrax::HumanReadableType,
-                                               Hyrax::Noid,
-                                               Hyrax::Serializers,
-                                               Hydra::WithDepositor,
-                                               Hydra::AccessControls::Embargoable,
-                                               Solrizer::Common,
-                                               Hyrax::Suppressible,
-                                               Hyrax::CollectionNesting)
-  end
-
-  describe '#to_s' do
-    it 'uses the provided titles' do
-      subject.title = %w[Hello World]
-      expect(subject.to_s).to include 'Hello'
-      expect(subject.to_s).to include 'World'
-    end
-  end
-
-  describe 'human_readable_type' do
-    it 'has a default' do
-      expect(subject.human_readable_type).to eq 'Essential Work'
-    end
-    it 'is settable (deprecated)' do
-      allow(Deprecation).to receive(:warn)
-      EssentialWork.human_readable_type = 'Custom Type'
-      expect(subject.human_readable_type).to eq 'Custom Type'
-    end
-  end
-
-  it 'inherits (and extends) to_solr behaviors from superclass' do
-    expect(subject.to_solr.keys).to include(:id)
-    expect(subject.to_solr.keys).to include('has_model_ssim')
-  end
-
-  describe 'indexer' do
-    let(:klass) { Class.new }
-
-    it 'is settable' do
-      EssentialWork.indexer = klass
-      expect(EssentialWork.indexer).to eq klass
-    end
-  end
-
-  describe '#update_nested_collection_relationship_indices', :with_nested_reindexing do
-    it 'will be called after save' do
-      expect(Samvera::NestingIndexer).to receive(:reindex_relationships).with(id: kind_of(String), extent: kind_of(String))
-      subject.save!
-    end
-  end
-end

data/spec/models/job_io_wrapper_spec.rb

@@ -1,172 +0,0 @@
-RSpec.describe JobIoWrapper, type: :model do
-  let(:user) { build(:user) }
-  let(:path) { fixture_path + '/world.png' }
-  let(:file_set_id) { 'bn999672v' }
-  let(:file_set) { instance_double(FileSet, id: file_set_id, uri: 'http://127.0.0.1/rest/fake/bn/99/96/72/bn999672v') }
-  let(:args) { { file_set_id: file_set_id, user: user, path: path } }
-
-  subject(:wrapper) { described_class.new(args) }
-
-  it 'requires attributes' do
-    expect { described_class.create! }.to raise_error ActiveRecord::RecordInvalid
-    expect { described_class.create!(file_set_id: file_set_id, path: path) }.to raise_error ActiveRecord::RecordInvalid
-    expect { described_class.create!(file_set_id: file_set_id, user: user) }.to raise_error ActiveRecord::RecordInvalid
-    expect { subject.save! }.not_to raise_error
-  end
-
-  describe '.create_with_wrapped_params!' do
-    let(:local_file) { File.open(path) }
-    let(:relation) { :remastered }
-
-    subject { described_class.create_with_varied_file_handling!(user: user, file_set: file_set, file: file, relation: relation) }
-
-    context 'with Rack::Test::UploadedFile' do
-      let(:file) { Rack::Test::UploadedFile.new(path, 'image/png') }
-
-      it 'creates a JobIoWrapper' do
-        expected_create_args = { user: user, relation: relation.to_s, file_set_id: file_set.id, path: file.path, original_name: 'world.png' }
-        expect(JobIoWrapper).to receive(:create!).with(expected_create_args)
-        subject
-      end
-    end
-
-    context 'with ::File' do
-      let(:file) { local_file }
-
-      it 'creates a JobIoWrapper' do
-        expected_create_args = { user: user, relation: relation.to_s, file_set_id: file_set.id, path: file.path }
-        expect(JobIoWrapper).to receive(:create!).with(expected_create_args)
-        subject
-      end
-    end
-
-    context 'with Hyrax::UploadedFile' do
-      let(:file) { Hyrax::UploadedFile.new(user: user, file_set_uri: file_set.uri, file: local_file) }
-
-      it 'creates a JobIoWrapper' do
-        expected_create_args = { user: user, relation: relation.to_s, file_set_id: file_set.id, uploaded_file: file, path: file.uploader.path }
-        expect(JobIoWrapper).to receive(:create!).with(expected_create_args)
-        subject
-      end
-    end
-  end
-
-  describe 'uploaded_file' do
-    let(:other_path) { fixture_path + '/image.jpg' }
-    let(:uploaded_file) { Hyrax::UploadedFile.new(user: user, file_set_uri: file_set.uri, file: File.new(other_path)) }
-
-    # context 'path only' is the rest of this file
-
-    context 'in leiu of path' do
-      let(:args) { { file_set_id: file_set_id, user: user, uploaded_file: uploaded_file } }
-
-      it 'validates and persists' do
-        expect { subject.save! }.not_to raise_error
-      end
-      it '#read routes to the uploaded_file' do
-        expect(subject).to receive(:file_from_uploaded_file!).and_call_original
-        subject.read
-      end
-      it '#mime_type and #original_name draw from the uploaded_file' do
-        expect(subject.mime_type).to eq('image/jpeg')
-        expect(subject.original_name).to eq('image.jpg')
-      end
-    end
-
-    context 'along with path (on shared filesystem)' do
-      let(:args) { { file_set_id: file_set_id, user: user, uploaded_file: uploaded_file, path: path } }
-
-      it 'validates and persists' do
-        expect { subject.save! }.not_to raise_error
-      end
-      it '#read routes to the path' do
-        expect(subject).not_to receive(:file_from_uploaded_file!)
-        subject.read
-      end
-      it '#mime_type and #original_name draw from the uploaded_file' do
-        expect(subject.mime_type).to eq('image/jpeg')
-        expect(subject.original_name).to eq('image.jpg')
-      end
-    end
-
-    context 'along with path (independent worker filesystems)' do
-      let(:deadpath) { fixture_path + '/some_file_that_does_not_exist.wav' }
-      let(:args) { { file_set_id: file_set_id, user: user, uploaded_file: uploaded_file, path: deadpath } }
-
-      it 'validates and persists' do
-        expect { subject.save! }.not_to raise_error
-      end
-      it '#read routes to the uploaded_file' do
-        expect(subject).to receive(:file_from_uploaded_file!).and_call_original
-        subject.read
-      end
-      it '#mime_type and #original_name draw from the uploaded_file' do
-        expect(subject.mime_type).to eq('image/jpeg')
-        expect(subject.original_name).to eq('image.jpg')
-      end
-    end
-  end
-
-  it 'has a #user' do
-    expect(subject.user).to eq(user)
-    expect(subject.user_id).to eq(user.id)
-  end
-
-  describe '#relation' do
-    it 'has default value' do
-      expect(subject.relation).to eq('original_file')
-    end
-    it 'accepts new value' do
-      subject.relation = 'remastered'
-      expect(subject.relation).to eq('remastered')
-    end
-  end
-
-  describe '#original_name' do
-    it 'extracts default value' do
-      expect(subject.original_name).to eq('world.png')
-    end
-    it 'accepts new value' do
-      subject.original_name = 'foobar'
-      expect(subject.original_name).to eq('foobar')
-    end
-  end
-
-  describe '#mime_type' do
-    it 'extracts default value' do
-      expect(subject.mime_type).to eq('image/png')
-    end
-    it 'accepts new value' do
-      subject.mime_type = 'text/plain'
-      expect(subject.mime_type).to eq('text/plain')
-    end
-    it 'uses original_name if set' do
-      subject.original_name = '汉字.jpg'
-      expect(subject.mime_type).to eq('image/jpeg')
-      subject.original_name = 'no_suffix'
-      expect(subject.mime_type).to eq('application/octet-stream')
-    end
-  end
-
-  describe '#file_actor' do
-    let(:file_actor) { Hyrax::Actors::FileActor.new(file_set, subject.relation, user) }
-
-    it 'produces an appropriate FileActor' do
-      allow(FileSet).to receive(:find).with(file_set_id).and_return(file_set)
-      expect(subject.file_actor).to eq(file_actor)
-    end
-  end
-
-  describe '#read' do
-    it 'delivers contents' do
-      expect(subject.read).to eq(File.open(path, 'rb').read)
-    end
-    context 'text file' do
-      let(:path) { fixture_path + '/png_fits.xml' }
-
-      it 'delivers contents' do
-        expect(subject.read).to eq(File.open(path, 'rb').read)
-      end
-    end
-  end
-end

data/spec/models/proxy_deposit_request_spec.rb

@@ -1,152 +0,0 @@
-RSpec.describe ProxyDepositRequest, type: :model do
-  let(:sender) { create(:user) }
-  let(:receiver) { create(:user) }
-  let(:receiver2) { create(:user) }
-  let(:work_id) { '123abc' }
-  let(:stubbed_work_query_service_class) { double(new: work_query_service) }
-  let(:work_query_service) { double(work: work) }
-  let(:work) { double('Work') }
-
-  subject do
-    described_class.new(work_id: work_id, sending_user: sender,
-                        receiving_user: receiver, sender_comment: "please take this")
-  end
-
-  # Injecting a different work_query_service_class to avoid hitting SOLR and Fedora; I need an
-  # instance variable as mocks are not allowed in the around blocks
-  # rubocop:disable RSpec/InstanceVariable
-  before do
-    @original_work_query_service_class = described_class.work_query_service_class
-    described_class.work_query_service_class = stubbed_work_query_service_class
-  end
-
-  after do
-    described_class.work_query_service_class = @original_work_query_service_class
-  end
-  # rubocop:enable RSpec/InstanceVariable
-
-  its(:status) { is_expected.to eq described_class::PENDING }
-  it { is_expected.to be_pending }
-  its(:fulfillment_date) { is_expected.to be_nil }
-  its(:sender_comment) { is_expected.to eq 'please take this' }
-
-  it { is_expected.to delegate_method(:to_s).to(:work_query_service) }
-  it { is_expected.to delegate_method(:work).to(:work_query_service) }
-  it { is_expected.to delegate_method(:deleted_work?).to(:work_query_service) }
-
-  context '.incoming_for' do
-    it 'returns non-deleted requests for the receiving_user' do
-      deleted_work_service = double(deleted_work?: true)
-      found_work_service = double(deleted_work?: false)
-
-      found = create(:proxy_deposit_request, work_id: 'abc', sending_user: sender, receiving_user: receiver)
-      allow(stubbed_work_query_service_class).to receive(:new).with(id: 'abc').and_return(found_work_service)
-
-      _deleted = create(:proxy_deposit_request, work_id: 'efg', sending_user: sender, receiving_user: receiver)
-      allow(stubbed_work_query_service_class).to receive(:new).with(id: 'efg').and_return(deleted_work_service)
-
-      _not_to_find = create(:proxy_deposit_request, work_id: 'hij', sending_user: receiver, receiving_user: sender)
-      expect(described_class.incoming_for(user: receiver)).to eq([found])
-    end
-  end
-
-  context '.outgoing_for' do
-    it 'returns only requests for the sending_user' do
-      found = create(:proxy_deposit_request, work_id: 'abc', sending_user: sender, receiving_user: receiver)
-      _not_to_find = create(:proxy_deposit_request, work_id: 'hij', sending_user: receiver, receiving_user: sender)
-      expect(described_class.outgoing_for(user: sender)).to eq([found])
-    end
-  end
-
-  context '#status' do
-    it 'is protected by enum enforcement' do
-      expect { described_class.new(status: 'not_valid') }.to raise_error(ArgumentError)
-    end
-
-    # Because the Rails documentation says "Declare an enum attribute where the values map to integers in the database, but can be queried by name." but appears to not be the case.
-    it 'is persisted as a string' do
-      subject.cancel!
-      values = described_class.connection.execute("SELECT * FROM #{described_class.quoted_table_name}")
-      expect(values.first.fetch('status')).to eq(described_class::CANCELED)
-    end
-  end
-
-  describe '#transfer!' do
-    it 'will change the status, fulfillment_date, and perform later the ContentDepositorChangeEventJob' do
-      allow(ContentDepositorChangeEventJob).to receive(:perform_later)
-      subject.transfer!
-      expect(subject.status).to eq(described_class::ACCEPTED)
-      expect(subject.fulfillment_date).to be_a(Time)
-      expect(subject).to be_accepted
-    end
-  end
-
-  describe '#cancel!' do
-    it 'will change the status, fulfillment_date' do
-      subject.cancel!
-      expect(subject.status).to eq(described_class::CANCELED)
-      expect(subject.fulfillment_date).to be_a(Time)
-      expect(subject).to be_canceled
-    end
-  end
-
-  describe '#reject!' do
-    it 'will change the status, fulfillment_date, and receiver comment' do
-      subject.reject!('a comment')
-      expect(subject.status).to eq(described_class::REJECTED)
-      expect(subject.fulfillment_date).to be_a(Time)
-      expect(subject.receiver_comment).to eq('a comment')
-      expect(subject).to be_rejected
-    end
-  end
-
-  describe 'transfer' do
-    context 'when the transfer_to user is not found' do
-      it 'raises an error' do
-        subject.transfer_to = 'dave'
-        expect(subject).not_to be_valid
-        expect(subject.errors[:transfer_to]).to eq(['must be an existing user'])
-      end
-    end
-
-    context 'when the transfer_to user is found' do
-      it 'creates a transfer_request' do
-        subject.transfer_to = receiver.user_key
-        expect { subject.save! }.to change { receiver.mailbox.inbox(unread: true).count }
-          .from(0).to(1)
-        proxy_request = receiver.proxy_deposit_requests.first
-        expect(proxy_request.work_id).to eq(work_id)
-        expect(proxy_request.sending_user).to eq(sender)
-      end
-    end
-
-    context 'when the receiving user is the sending user' do
-      it 'raises an error' do
-        subject.transfer_to = sender.user_key
-        expect(subject).not_to be_valid
-        expect(subject.errors[:transfer_to]).to eq(['specify a different user to receive the work'])
-      end
-    end
-
-    context 'when the work is already being transferred' do
-      let(:subject2) { described_class.new(work_id: work_id, sending_user: sender, receiving_user: receiver2, sender_comment: 'please take this') }
-
-      it 'raises an error' do
-        subject.save!
-        expect(subject2).not_to be_valid
-        expect(subject2.errors[:open_transfer]).to eq(['must close open transfer on the work before creating a new one'])
-      end
-
-      context 'when the first transfer is closed' do
-        before do
-          subject.status = described_class::ACCEPTED
-        end
-
-        it 'does not raise an error' do
-          subject.save!
-          expect(subject2).to be_valid
-        end
-      end
-    end
-  end
-end