curation_concerns 0.3.0 → 0.4.0

data/spec/indexers/{file_set_indexing_service_spec.rb → file_set_indexer_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe CurationConcerns::FileSetIndexingService do
+describe CurationConcerns::FileSetIndexer do
   let(:file_set) do
     FileSet.new(
       id: 'foo123',
@@ -28,12 +28,21 @@ describe CurationConcerns::FileSetIndexingService do
       end
   end
 
+  let(:mock_file) do
+    mock_model("MockFile",
+               content: "asdf",
+               digest: ["urn:sha1:f794b23c0c6fe1083d0ca8b58261a078cd968967"]
+              )
+  end
+  let(:indexer) { described_class.new(file_set) }
+
   describe '#generate_solr_document' do
     before do
       allow(file_set).to receive(:label).and_return('CastoriaAd.tiff')
       allow(CurationConcerns::ThumbnailPathService).to receive(:call).and_return('/downloads/foo123?file=thumbnail')
+      allow(file_set).to receive(:original_file).and_return(mock_file)
     end
-    subject { described_class.new(file_set).generate_solr_document }
+    subject { indexer.generate_solr_document }
 
     it 'has fields' do
       expect(subject[Solrizer.solr_name('hasRelatedMediaFragment', :symbol)]).to eq 'foo123'
@@ -64,6 +73,35 @@ describe CurationConcerns::FileSetIndexingService do
       expect(subject['all_text_timv']).to eq('abcxyz')
       expect(subject['height_is']).to eq 500
       expect(subject['width_is']).to eq 600
+      expect(subject[Solrizer.solr_name('digest', :symbol)]).to eq 'urn:sha1:f794b23c0c6fe1083d0ca8b58261a078cd968967'
+    end
+  end
+
+  describe '#file_format' do
+    subject { indexer.send(:file_format) }
+
+    context 'when both mime and format_label are present' do
+      before do
+        allow(file_set).to receive(:mime_type).and_return('image/png')
+        allow(file_set).to receive(:format_label).and_return(['Portable Network Graphics'])
+      end
+      it { is_expected.to eq 'png (Portable Network Graphics)' }
+    end
+
+    context 'when just mime type is present' do
+      before do
+        allow(file_set).to receive(:mime_type).and_return('image/png')
+        allow(file_set).to receive(:format_label).and_return([])
+      end
+      it { is_expected.to eq 'png' }
+    end
+
+    context 'when just format_label is present' do
+      before do
+        allow(file_set).to receive(:mime_type).and_return('')
+        allow(file_set).to receive(:format_label).and_return(['Portable Network Graphics'])
+      end
+      it { is_expected.to eq ['Portable Network Graphics'] }
     end
   end
 end

data/spec/indexers/{generic_work_indexing_service_spec.rb → work_indexer_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe CurationConcerns::WorkIndexingService do
+describe CurationConcerns::WorkIndexer do
   # TODO: file_set_ids returns an empty set unless you persist the work
   let(:user) { create(:user) }
   let!(:generic_work) { create(:work_with_one_file, user: user) }

data/spec/inputs/multi_value_with_help_input_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'MultiValueWithHelpInput', type: :input do
+  subject { input_for file, field, as: :multi_value_with_help, required: true }
+  let(:file) { FileSet.new }
+
+  context "when the field has a translation" do
+    let(:field) { :language }
+    before do
+      allow_any_instance_of(MultiValueWithHelpInput).to receive(:raw_label_text).and_return('Language')
+      allow_any_instance_of(MultiValueWithHelpInput).to receive(:translate_from_namespace).and_return('default translation')
+      allow_any_instance_of(MultiValueWithHelpInput).to receive(:translate_from_namespace).with(:metadata_help).and_return(
+        'The language of the file content.'
+      )
+    end
+
+    it 'renders help icon' do
+      expect(subject).to have_selector('a[data-toggle=popover][data-original-title=Language]')
+      expect(subject).to have_selector('a[data-toggle=popover][data-content="The language of the file content."]')
+      expect(subject).to have_selector('i.help-icon')
+    end
+  end
+
+  context "when the field doesn't have a translation" do
+    let(:field) { :date_modified }
+    it 'renders help icon' do
+      expect(subject).to have_selector('a[data-toggle=popover][data-original-title="Date modified"]')
+      expect(subject).to have_selector('a[data-toggle=popover][data-content="Date modified"]')
+      expect(subject).to have_selector('i.help-icon')
+    end
+  end
+end

data/spec/inputs/select_with_help_input_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe 'SelectWithHelpInput', type: :input do
+  subject { input_for form, :resource_type, options }
+  let(:file) { FileSet.new }
+  let(:form_class) do
+    Class.new do
+      include HydraEditor::Form
+      self.model_class = FileSet
+      self.terms = [:resource_type]
+    end
+  end
+  let(:form) { form_class.new(FileSet.new) }
+  let(:collection) { CurationConcerns.config.resource_types }
+  let(:base_options) do
+    { as: :select_with_help, collection: collection,
+      input_html: { class: 'form-control', multiple: true } }
+  end
+  let(:options) { base_options }
+
+  it "does not be required by default" do
+    expect(subject).to have_selector 'select'
+    expect(subject).not_to match(/required/)
+  end
+
+  context 'with File Edit' do
+    let(:user) { create(:user) }
+    let(:file) { FileSet.create(label: 'f1') { |f| f.apply_depositor_metadata(user) } }
+    let(:form) { CurationConcerns::Forms::FileSetEditForm.new(file) }
+    let(:base_options) do
+      { as: :select_with_help, collection: collection,
+        input_html: { class: 'form-control', multiple: true } }
+    end
+    let(:options) { base_options }
+
+    subject { input_for form, :resource_type, options }
+
+    it "is not required by default" do
+      expect(subject).to have_selector 'select'
+      expect(subject).not_to match(/required/)
+    end
+  end
+end

data/spec/inputs/select_with_modal_help_input_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'SelectWithModalHelpInput', type: :input do
+  subject { input_for file, :rights, options }
+  let(:file) { FileSet.new }
+  let(:base_options) { { as: :select_with_modal_help, required: true, collection: RightsService.select_options } }
+  let(:options) { base_options }
+
+  context "when a blank is requested" do
+    let(:options) { base_options.merge(include_blank: true) }
+    it 'renders a blank option' do
+      expect(subject).to have_selector 'select option[value=""]'
+    end
+  end
+
+  context "when a blank is not requested" do
+    it 'has no blanks' do
+      expect(subject).to have_selector 'select option:first-child', text: 'Attribution 3.0 United States'
+    end
+  end
+end

data/spec/jobs/import_url_job_spec.rb

@@ -13,7 +13,6 @@ describe ImportUrlJob do
   end
 
   let(:file_set_id) { 'abc123' }
-  let(:actor) { double }
 
   let(:mock_response) do
     double('response').tap do |http_res|
@@ -24,8 +23,10 @@ describe ImportUrlJob do
   end
 
   context 'after running the job' do
+    let(:actor) { double }
     before do
       allow(ActiveFedora::Base).to receive(:find).with(file_set_id).and_return(file_set)
+      allow(file_set).to receive(:reload)
       allow(CurationConcerns::FileSetActor).to receive(:new).with(file_set, user).and_return(actor)
     end
 
@@ -35,4 +36,35 @@ describe ImportUrlJob do
       described_class.perform_now(file_set_id)
     end
   end
+
+  context "when a batch update job is running too" do
+    let(:title) { { file_set.id => ['File One'] } }
+    let(:metadata) { {} }
+    let(:visibility) { nil }
+
+    let(:upload_set) { UploadSet.create }
+    let(:upload_set_job) { UploadSetUpdateJob.perform_now(user.user_key, upload_set.id, title, metadata, visibility) }
+    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)
+      allow_any_instance_of(CurationConcerns::FileSetActor).to receive(:create_content)
+      allow_any_instance_of(Ability).to receive(:can?).and_return(true)
+      expect_any_instance_of(Net::HTTP).to receive(:request_get).with(file_hash).and_yield(mock_response)
+    end
+
+    it "does not kill all the metadata set by other processes" do
+      # run the batch job to set the title
+      file_set.update(title: ['File One'])
+
+      # run the import job
+      described_class.perform_now(file_set_id)
+
+      # 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
 end

data/spec/jobs/ingest_file_job_spec.rb

@@ -3,24 +3,34 @@ require 'spec_helper'
 describe IngestFileJob do
   let(:file_set) { create(:file_set) }
   let(:filename) { fixture_file_path('/world.png') }
+  let(:user)     { create(:user) }
 
-  it 'uses the provided mime_type' do
-    described_class.perform_now(file_set.id, filename, 'image/png', 'bob')
-    expect(file_set.reload.original_file.mime_type).to eq 'image/png'
+  context 'when givin a mime_type' do
+    it 'uses a provided mime_type' do
+      described_class.perform_now(file_set.id, filename, 'image/png', 'bob')
+      expect(file_set.reload.original_file.mime_type).to eq 'image/png'
+    end
   end
 
-  context 'with two existing versions from different users' do
-    let(:file1)       { fixture_file_path 'world.png' }
-    let(:file2)       { fixture_file_path 'small_file.txt' }
-    let(:actor1)      { described_class.new(file_set, user) }
-    let(:actor2)      { described_class.new(file_set, second_user) }
+  context 'when not given a mime_type' do
+    it 'does not decorate File when not given mime_type' do
+      # Mocking CC Versioning here as it will be the versioning machinery called by the job.
+      # The parameter versioning: false instructs the machinery in Hydra::Works NOT to do versioning. So it can be handled later on.
+      allow(CurationConcerns::VersioningService).to receive(:create)
+      expect(Hydra::Works::AddFileToFileSet).to receive(:call).with(file_set, instance_of(::File), :original_file, versioning: false)
+      described_class.perform_now(file_set.id, filename, nil, 'bob')
+    end
+  end
 
-    let(:second_user) { create(:user) }
+  context 'with two existing versions from different users' do
+    let(:file1)    { fixture_file_path 'world.png' }
+    let(:file2)    { fixture_file_path 'small_file.txt' }
     let(:versions) { file_set.reload.original_file.versions }
+    let(:user2) { create(:user) }
 
     before do
-      described_class.perform_now(file_set.id, file1, 'image/png', 'bob')
-      described_class.perform_now(file_set.id, file2, 'text/plain', 'bess')
+      described_class.perform_now(file_set.id, file1, 'image/png', user.user_key)
+      described_class.perform_now(file_set.id, file2, 'text/plain', user2.user_key)
     end
 
     it 'has two versions' do
@@ -33,13 +43,16 @@ describe IngestFileJob do
       expect(file_set.original_file.original_name).to eq 'small_file.txt'
 
       # the user for each version
-      expect(VersionCommitter.where(version_id: versions.first.uri).pluck(:committer_login)).to eq ['bob']
-      expect(VersionCommitter.where(version_id: versions.last.uri).pluck(:committer_login)).to eq ['bess']
+      expect(VersionCommitter.where(version_id: versions.first.uri).pluck(:committer_login)).to eq [user.user_key]
+      expect(VersionCommitter.where(version_id: versions.last.uri).pluck(:committer_login)).to eq [user2.user_key]
     end
   end
 
-  it 'runs the after_create_content callback with file_set and user arguments' do
-    expect(CurationConcerns.config.callback).to receive(:run).with(:after_create_content, file_set, 'bob').exactly(1).times
-    described_class.perform_now(file_set.id, filename, 'image/png', 'bob')
+  describe "the after_create_contentcallback" do
+    subject { CurationConcerns.config.callback }
+    it 'runs with file_set and user arguments' do
+      expect(subject).to receive(:run).with(:after_create_content, file_set, user)
+      described_class.perform_now(file_set.id, filename, 'image/png', user.user_key)
+    end
   end
 end

data/spec/jobs/upload_set_update_job_spec.rb

@@ -4,27 +4,40 @@ describe UploadSetUpdateJob do
   let(:user) { create(:user) }
   let(:upload_set) { UploadSet.create }
 
-  let!(:file)  { create(:file_set, user: user, upload_set: upload_set) }
-  let!(:file2) { create(:file_set, user: user, upload_set: upload_set) }
+  let(:work)  { create(:work, user: user, upload_set: upload_set) }
+  let(:work2) { create(:work, user: user, upload_set: upload_set) }
+
+  before do
+    allow(CurationConcerns.config.callback).to receive(:run)
+    allow(CurationConcerns.config.callback).to receive(:set?)
+      .with(:after_upload_set_update_success)
+      .and_return(true)
+    allow(CurationConcerns.config.callback).to receive(:set?)
+      .with(:after_upload_set_update_failure)
+      .and_return(true)
+  end
 
   describe "#perform" do
-    let(:title) { { file.id => ['File One'], file2.id => ['File Two'] } }
+    let(:title) { { work.id => ['File One'], work2.id => ['File Two'] } }
     let(:metadata) { { tag: [''] } }
     let(:visibility) { nil }
 
     subject { described_class.perform_now(user.user_key, upload_set.id, title, metadata, visibility) }
 
-    it "updates file metadata" do
-      expect(subject).to be true
-      expect(file.reload.title).to eq ['File One']
+    it "updates work metadata" do
+      expect(CurationConcerns.config.callback).to receive(:run).with(:after_upload_set_update_success, user, upload_set)
+      subject
+      expect(work.reload.title).to eq ['File One']
+      expect(work2.reload.title).to eq ['File Two']
     end
 
-    context "when user does not have permission to edit all of the files" do
-      before do
-        expect_any_instance_of(User).to receive(:can?).with(:edit, file).and_return(true)
-        expect_any_instance_of(User).to receive(:can?).with(:edit, file2).and_return(false)
+    context "when user does not have permission to edit all of the works" do
+      it "sends the failure message" do
+        expect_any_instance_of(User).to receive(:can?).with(:edit, work).and_return(true)
+        expect_any_instance_of(User).to receive(:can?).with(:edit, work2).and_return(false)
+        expect(CurationConcerns.config.callback).to receive(:run).with(:after_upload_set_update_failure, user, upload_set)
+        subject
       end
-      it { is_expected.to be false }
     end
   end
 end

data/spec/lib/curation_concerns/messages_spec.rb

@@ -41,7 +41,7 @@ describe CurationConcerns::Messages do
     it 'renders a success message for multiple files' do
       node = Capybara::Node::Simple.new(message.multiple_success(upload_set_id, multiple))
       expect(node).to have_selector("span[id=\"ss-1\"]", text: 'These files have been saved.')
-      expect(node).to have_selector("a[data-content=\"#{file_list}\"][rel=\"popover\"][data-title=\"Files uploaded successfully\"]")
+      expect(node).to have_selector("a[data-content=\"#{file_list}\"][data-toggle=\"popover\"][data-title=\"Files uploaded successfully\"]")
     end
   end
 
@@ -57,7 +57,7 @@ describe CurationConcerns::Messages do
     it 'renders a failure message for multiple files' do
       node = Capybara::Node::Simple.new(message.multiple_failure(upload_set_id, multiple))
       expect(node).to have_selector("span[id=\"ss-1\"]", text: 'These files could not be updated. You do not have sufficient privileges to edit them.')
-      expect(node).to have_selector("a[data-content=\"#{file_list}\"][rel=\"popover\"][data-title=\"Files failed\"]")
+      expect(node).to have_selector("a[data-content=\"#{file_list}\"][data-toggle=\"popover\"][data-title=\"Files failed\"]")
     end
   end
 

data/spec/lib/curation_concerns/name_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe CurationConcerns::Name do
+  let(:name) { described_class.new(GenericWork) }
+
+  describe "route_key" do
+    subject { name.route_key }
+    it { is_expected.to eq 'curation_concerns_generic_works' }
+  end
+
+  describe "singular_route_key" do
+    subject { name.singular_route_key }
+    it { is_expected.to eq 'curation_concerns_generic_work' }
+  end
+
+  describe "param_key" do
+    subject { name.param_key }
+    it { is_expected.to eq 'generic_work' }
+  end
+end

data/spec/lib/curation_concerns/null_logger_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe CurationConcerns::NullLogger do
+  subject { described_class.new }
+  its(:debug) { is_expected.to be_nil }
+  its(:info) { is_expected.to be_nil }
+  its(:warn) { is_expected.to be_nil }
+  its(:error) { is_expected.to be_nil }
+  its(:fatal) { is_expected.to be_nil }
+end

data/spec/models/curation_concerns/collection_behavior_spec.rb

@@ -17,19 +17,49 @@ describe CurationConcerns::CollectionBehavior do
     it { is_expected.to eq CurationConcerns::CollectionIndexer }
   end
 
-  describe '::bytes' do
+  describe '.bytes' do
     subject { collection.bytes }
 
     context 'with no items' do
       before { collection.save }
-      it { is_expected.to eq 0 }
+      it "gets zero without querying solr" do
+        expect(ActiveFedora::SolrService).not_to receive(:query)
+        is_expected.to eq 0
+      end
     end
 
-    context 'with two 50 byte files' do
-      let(:bitstream) { double('content', size: '50') }
-      let(:file) { mock_model ::FileSet, content: bitstream }
-      before { allow(collection).to receive(:members).and_return([file, file]) }
-      it { is_expected.to eq 100 }
+    # Calculating the size of the Collection should only hit Solr.
+    # This base case querries solr in an integration test
+    context 'with indexed Works and FileSets', :integration do
+      let(:file1) { FactoryGirl.build(:file_set, file_size: ['100']) }
+      let(:file2) { FactoryGirl.build(:file_set, file_size: ['100']) }
+      let(:file3) { FactoryGirl.build(:file_set, file_size: ['9000'], id: 'fumid') }
+      let(:work1) { FactoryGirl.build(:generic_work) }
+      let(:work2) { FactoryGirl.build(:generic_work) }
+      let(:work3) { FactoryGirl.build(:generic_work, id: 'dumid') }
+      before do
+        # Save collection to get ids
+        collection.save
+        # Create relationships so member_ids are created
+        collection.members = [work1, work2]
+        work1.members = [file1]
+        work2.members = [file2]
+        # Create a relatinship not in the collection.
+        work3.members = [file3]
+
+        # Manually Call Indexing to put the data in Solr
+        ActiveFedora::SolrService.add(collection.to_solr)
+        ActiveFedora::SolrService.add(work1.to_solr, softCommit: true)
+        ActiveFedora::SolrService.add(work2.to_solr, softCommit: true)
+        ActiveFedora::SolrService.add(work3.to_solr, softCommit: true)
+        ActiveFedora::SolrService.add(file1.to_solr, softCommit: true)
+        ActiveFedora::SolrService.add(file2.to_solr, softCommit: true)
+        ActiveFedora::SolrService.add(file3.to_solr, softCommit: true)
+      end
+
+      it "is the correct aggregate size" do
+        is_expected.to eq 200
+      end
     end
   end
 
@@ -46,7 +76,7 @@ describe CurationConcerns::CollectionBehavior do
     end
 
     context 'with itself' do
-      it 'does not add it to the collection\'s members' do
+      it 'does not add it to the collection members' do
         expect do
           subject.add_member(subject)
         end.to_not change { subject.members.size }
@@ -75,7 +105,7 @@ describe CurationConcerns::CollectionBehavior do
     end
   end
 
-  context 'is a pcdm:Collection instance' do
+  describe 'intrinsic properties' do
     let(:collection1) { FactoryGirl.build(:collection) }
     let(:work1) { FactoryGirl.build(:work) }
 
@@ -83,7 +113,8 @@ describe CurationConcerns::CollectionBehavior do
       expect(subject.pcdm_collection?).to be true
       expect(subject.type).to include Hydra::PCDM::Vocab::PCDMTerms.Collection
     end
-    it 'does not be a pcdm:Object' do
+
+    it 'is not a pcdm:Object' do
       expect(subject.pcdm_object?).to be false
       expect(subject.type).to_not include Hydra::PCDM::Vocab::PCDMTerms.Object
     end

data/spec/models/curation_concerns/work_behavior_spec.rb

@@ -4,7 +4,6 @@ describe CurationConcerns::WorkBehavior do
   before do
     class EssentialWork < ActiveFedora::Base
       include CurationConcerns::WorkBehavior
-      include CurationConcerns::BasicMetadata
     end
   end
   after do
@@ -23,19 +22,8 @@ describe CurationConcerns::WorkBehavior do
       subject.title = %w(Hello World)
       expect(subject.to_s).to eq('Hello | World')
     end
-
-    it 'falls back on label if no titles are given' do
-      subject.title = []
-      subject.label = 'Spam'
-      expect(subject.to_s).to eq('Spam')
-    end
-
-    it 'with no label or titles it is "No Title"' do
-      subject.title = []
-      subject.label = nil
-      expect(subject.to_s).to eq('No Title')
-    end
   end
+
   describe 'human_readable_type' do
     it 'has a default' do
       expect(subject.human_readable_type).to eq 'Essential Work'

data/spec/models/file_set_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 # It includes the CurationConcerns::FileSetBehavior module and nothing else
 # So this test covers both the FileSetBehavior module and the generated FileSet model
 describe FileSet do
-  let(:user) { FactoryGirl.find_or_create(:jill) }
+  let(:user) { create(:user) }
 
   describe 'rdf type' do
     subject { described_class.new.type }
@@ -147,7 +147,7 @@ describe FileSet do
 
   describe '#indexer' do
     subject { described_class.indexer }
-    it { is_expected.to eq CurationConcerns::FileSetIndexingService }
+    it { is_expected.to eq CurationConcerns::FileSetIndexer }
   end
 
   it 'supports multi-valued fields in solr' do
@@ -361,10 +361,25 @@ describe FileSet do
     end
   end
 
+  describe '#where_digest_is' do
+    let(:file) { create(:file_set) }
+    let(:file_path) { fixture_path + '/small_file.txt' }
+    let(:digest_string) { '88fb4e88c15682c18e8b19b8a7b6eaf8770d33cf' }
+    before do
+      allow(file).to receive(:warn) # suppress virus warnings
+      of = file.build_original_file
+      of.content = File.open(file_path)
+      file.save
+      file.update_index
+    end
+    subject { described_class.where_digest_is(digest_string).first }
+    it { is_expected.to eq(file) }
+  end
+
   describe 'to_solr' do
     let(:indexer) { double(generate_solr_document: {}) }
     before do
-      allow(CurationConcerns::FileSetIndexingService).to receive(:new)
+      allow(CurationConcerns::FileSetIndexer).to receive(:new)
         .with(subject).and_return(indexer)
     end
 
@@ -374,7 +389,7 @@ describe FileSet do
     end
 
     it 'has human readable type' do
-      expect(subject.to_solr.fetch('human_readable_type_tesim')).to eq 'File Set'
+      expect(subject.to_solr.fetch('human_readable_type_tesim')).to eq 'File'
     end
   end
 

data/spec/models/generic_work_spec.rb

@@ -9,6 +9,11 @@ describe GenericWork do
     expect(subject.title).to eq ['foo']
   end
 
+  describe '.model_name' do
+    subject { described_class.model_name.singular_route_key }
+    it { is_expected.to eq 'curation_concerns_generic_work' }
+  end
+
   context 'with attached files' do
     subject { FactoryGirl.create(:work_with_files) }
 
@@ -20,7 +25,7 @@ describe GenericWork do
 
   describe '#indexer' do
     subject { described_class.indexer }
-    it { is_expected.to eq CurationConcerns::WorkIndexingService }
+    it { is_expected.to eq CurationConcerns::WorkIndexer }
   end
 
   describe 'to_solr' do
@@ -39,6 +44,6 @@ describe GenericWork do
   describe '#to_partial_path' do
     let(:work) { described_class.new }
     subject { work.to_partial_path }
-    it { is_expected.to eq 'curation_concerns/generic_works/generic_work' }
+    it { is_expected.to eq 'generic_works/generic_work' }
   end
 end

data/spec/models/quick_classification_query_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe CurationConcerns::QuickClassificationQuery do
+  let(:user) { create(:user) }
+
+  context "with no options" do
+    let(:query) { described_class.new(user) }
+    describe "#all?" do
+      subject { query.all? }
+      it { is_expected.to be true }
+    end
+
+    describe '#each' do
+      let(:thing) { double }
+      before do
+        # Ensure that no other test has altered the configuration:
+        allow(CurationConcerns.config).to receive(:registered_curation_concern_types).and_return(['GenericWork'])
+      end
+      it "calls the block once for every model" do
+        expect(thing).to receive(:test).with(GenericWork)
+        query.each do |f|
+          thing.test(f)
+        end
+      end
+    end
+  end
+
+  context "with models" do
+    let(:query) { described_class.new(user, models: ['dataset']) }
+    describe "#all?" do
+      subject { query.all? }
+      it { is_expected.to be false }
+    end
+  end
+end