curation_concerns 0.1.0 → 0.2.0

data/spec/forms/file_set_edit_form_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe CurationConcerns::Forms::FileSetEditForm do
+  subject { described_class.new(FileSet.new) }
+
+  describe '#terms' do
+    it 'returns a list' do
+      expect(subject.terms).to eq(
+        [:resource_type, :title, :creator, :contributor, :description, :tag,
+         :rights, :publisher, :date_created, :subject, :language, :identifier,
+         :based_near, :related_url,
+         :visibility_during_embargo, :visibility_after_embargo, :embargo_release_date,
+         :visibility_during_lease, :visibility_after_lease, :lease_expiration_date,
+         :visibility])
+    end
+
+    it "doesn't contain fields that users shouldn't be allowed to edit" do
+      # date_uploaded is reserved for the original creation date of the record.
+      expect(subject.terms).not_to include(:date_uploaded)
+    end
+  end
+
+  it 'initializes multivalued fields' do
+    expect(subject.title).to eq ['']
+  end
+
+  describe '.model_attributes' do
+    let(:params) do
+      ActionController::Parameters.new(
+        title: ['foo'],
+        "visibility" => "on-campus",
+        "visibility_during_embargo" => "restricted",
+        "embargo_release_date" => "2015-10-21",
+        "visibility_after_embargo" => "open",
+        "visibility_during_lease" => "open",
+        "lease_expiration_date" => "2015-10-21",
+        "visibility_after_lease" => "restricted"
+      )
+    end
+    subject { described_class.model_attributes(params) }
+
+    it 'changes only the title' do
+      expect(subject['title']).to eq ['foo']
+      expect(subject['visibility']).to eq('on-campus')
+      expect(subject['visibility_during_embargo']).to eq('restricted')
+      expect(subject['visibility_after_embargo']).to eq('open')
+      expect(subject['embargo_release_date']).to eq('2015-10-21')
+      expect(subject['visibility_during_lease']).to eq('open')
+      expect(subject['visibility_after_lease']).to eq('restricted')
+      expect(subject['lease_expiration_date']).to eq('2015-10-21')
+    end
+  end
+end

data/spec/forms/work_form_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe CurationConcerns::Forms::WorkForm do
+  before do
+    class PirateShip < ActiveFedora::Base
+      include CurationConcerns::BasicMetadata
+      include CurationConcerns::HasRepresentative
+    end
+
+    class PirateShipForm < described_class
+      self.model_class = ::PirateShip
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :PirateShipForm)
+    Object.send(:remove_const, :PirateShip)
+  end
+
+  let(:curation_concern) { create(:work_with_one_file) }
+  let(:title) { curation_concern.file_sets.first.title.first }
+  let(:file_id) { curation_concern.file_sets.first.id }
+  let(:ability) { nil }
+  let(:form) { PirateShipForm.new(curation_concern, ability) }
+
+  describe "#select_files" do
+    subject { form.select_files }
+    it { is_expected.to eq(title => file_id) }
+  end
+
+  describe '.model_attributes' do
+    let(:params) { ActionController::Parameters.new(
+      title: ['foo'],
+      description: [''],
+      visibility: 'open',
+      admin_set_id: '123',
+      representative_id: '456',
+      thumbnail_id: '789',
+      rights: 'http://creativecommons.org/licenses/by/3.0/us/')
+    }
+    subject { PirateShipForm.model_attributes(params) }
+
+    it 'permits parameters' do
+      expect(subject['title']).to eq ['foo']
+      expect(subject['description']).to be_empty
+      expect(subject['visibility']).to eq 'open'
+      expect(subject['rights']).to eq ['http://creativecommons.org/licenses/by/3.0/us/']
+    end
+
+    it 'excludes non-permitted params' do
+      expect(subject).not_to have_key 'admin_set_id'
+    end
+  end
+end

data/spec/helpers/catalog_helper_spec.rb

@@ -5,44 +5,44 @@ describe CurationConcerns::CatalogHelper do
     helper.params[:controller] = 'catalog'
     allow(helper).to receive(:blacklight_config).and_return(CatalogController.blacklight_config)
     allow(helper).to receive(:search_action_path) do |*args|
-      catalog_index_path *args
+      catalog_index_path(*args)
     end
   end
 
-  describe "all_type_tab" do
+  describe 'all_type_tab' do
     subject { helper.all_type_tab('All') }
 
-    context "when it is the active tab" do
+    context 'when it is the active tab' do
       it { should eq "<li class=\"active\"><a href=\"#\">All</a></li>" }
     end
 
-    context "when it is not the active tab" do
+    context 'when it is not the active tab' do
       before do
         helper.params[:f] = { 'generic_type_sim' => ['Work'] }
       end
       it { should eq "<li><a href=\"/catalog\">All</a></li>" }
     end
 
-    context "when other parameters are present" do
+    context 'when other parameters are present' do
       before do
         helper.params[:f] = { 'generic_type_sim' => ['Work'] }
         helper.params[:page] = 4
       end
-      it("should clear them") { should eq "<li><a href=\"/catalog\">All</a></li>" }
+      it('clears them') { should eq "<li><a href=\"/catalog\">All</a></li>" }
     end
   end
 
-  describe "type_tab" do
+  describe 'type_tab' do
     subject { helper.type_tab('Works', 'Work') }
 
-    context "when it is the active tab" do
+    context 'when it is the active tab' do
       before do
         helper.params[:f] = { 'generic_type_sim' => ['Work'] }
       end
       it { should eq "<li class=\"active\"><a href=\"#\">Works</a></li>" }
     end
 
-    context "when it is not the active tab" do
+    context 'when it is not the active tab' do
       it { should eq "<li><a href=\"/catalog?f%5Bgeneric_type_sim%5D%5B%5D=Work\">Works</a></li>" }
     end
 
@@ -54,5 +54,4 @@ describe CurationConcerns::CatalogHelper do
     #   it("should clear them") { should eq "<li><a href=\"/catalog?f%5Bgeneric_type_sim%5D%5B%5D=Work\">Works</a></li>" }
     # end
   end
-
 end

data/spec/helpers/configuration_helper_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 describe Blacklight::ConfigurationHelperBehavior do
-
-  describe "creator facet" do
+  describe 'creator facet' do
     before do
       allow(helper).to receive(:blacklight_config).and_return(CatalogController.blacklight_config)
     end

data/spec/helpers/curation_concerns/collections_helper_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 describe CurationConcerns::CollectionsHelper do
-
-  describe "#link_to_select_collection" do
+  describe '#link_to_select_collection' do
     let(:collection) { double(id: '123') }
     let(:collectible) { double(id: '456', human_readable_type: 'Generic Work', to_param: '456') }
     before do
@@ -10,13 +9,13 @@ describe CurationConcerns::CollectionsHelper do
     end
     subject { helper.link_to_select_collection(collectible) }
 
-    it "has a link that pops up a modal" do
+    it 'has a link that pops up a modal' do
       expect(subject).to have_selector 'a[data-toggle=modal][data-target="#456-modal"]'
       expect(subject).to have_link 'Add to a Collection', href: '#'
     end
   end
 
-  describe "#link_to_remove_from_collection" do
+  describe '#link_to_remove_from_collection' do
     let(:collection) { double(id: '123') }
     let(:collectible) { double(id: '456') }
     before do
@@ -24,15 +23,15 @@ describe CurationConcerns::CollectionsHelper do
     end
     subject { helper.link_to_remove_from_collection(collectible) }
 
-    it "has a form that routes to remove the collectible" do
+    it 'has a form that routes to remove the collectible' do
       expect(subject).to have_selector 'a[data-method=put]'
       expect(subject).to have_link 'Remove From Collection',
-        href: collections.collection_path('123', collection: { members: 'remove'},
-                                          batch_document_ids: [ '456' ])
+                                   href: collections.collection_path('123', collection: { members: 'remove' },
+                                                                            batch_document_ids: ['456'])
     end
   end
 
-  describe "#collection_options_for_select" do
+  describe '#collection_options_for_select' do
     before do
       allow(helper).to receive(:current_user).and_return(user)
     end
@@ -42,7 +41,7 @@ describe CurationConcerns::CollectionsHelper do
     let!(:collection3) { FactoryGirl.create(:collection, user: user, title: 'Three') }
     subject { helper.collection_options_for_select(collection2) }
 
-    it "excludes the passed in collection" do
+    it 'excludes the passed in collection' do
       expect(subject).to eq "<option value=\"#{collection1.id}\">#{collection1.title}</option>\n<option value=\"#{collection3.id}\">#{collection3.title}</option>"
     end
   end

data/spec/helpers/curation_concerns/file_set_helper_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe CurationConcerns::FileSetHelper do
+  describe '#media_display' do
+    let(:file_set) { SolrDocument.new(mime_type_ssi: mime_type) }
+    let(:mime_type) { 'image/tiff' }
+
+    before do
+      allow(helper).to receive(:media_display_partial).with(file_set)
+        .and_return('curation_concerns/file_sets/media_display/image')
+    end
+
+    it "renders a partial" do
+      expect(helper).to receive(:render)
+        .with('curation_concerns/file_sets/media_display/image', file_set: file_set)
+      helper.media_display(file_set)
+    end
+
+    it "takes options" do
+      expect(helper).to receive(:render)
+        .with('curation_concerns/file_sets/media_display/image', file_set: file_set, transcript_id: '123')
+      helper.media_display(file_set, transcript_id: '123')
+    end
+  end
+
+  describe '#media_display_partial' do
+    subject { helper.media_display_partial(file_set) }
+
+    let(:file_set) { SolrDocument.new(mime_type_ssi: mime_type) }
+
+    context "with an image" do
+      let(:mime_type) { 'image/tiff' }
+      it { is_expected.to eq 'curation_concerns/file_sets/media_display/image' }
+    end
+
+    context "with a video" do
+      let(:mime_type) { 'video/webm' }
+      it { is_expected.to eq 'curation_concerns/file_sets/media_display/video' }
+    end
+
+    context "with an audio" do
+      let(:mime_type) { 'audio/wav' }
+      it { is_expected.to eq 'curation_concerns/file_sets/media_display/audio' }
+    end
+
+    context "with a pdf" do
+      let(:mime_type) { 'application/pdf' }
+      it { is_expected.to eq 'curation_concerns/file_sets/media_display/pdf' }
+    end
+
+    context "with a word document" do
+      let(:mime_type) { 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' }
+      it { is_expected.to eq 'curation_concerns/file_sets/media_display/office_document' }
+    end
+
+    context "with anything else" do
+      let(:mime_type) { 'application/binary' }
+      it { is_expected.to eq 'curation_concerns/file_sets/media_display/default' }
+    end
+  end
+end

data/spec/helpers/render_constraints_helper_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
 describe CurationConcernsHelper do
-  describe "render_constraints_query" do
+  describe 'render_constraints_query' do
     before do
       # Stub methods from Blacklight::SearchFields
       allow(helper).to receive(:default_search_field).and_return(CatalogController.blacklight_config.default_search_field)
-      allow(helper).to receive(:label_for_search_field).and_return("Foo")
+      allow(helper).to receive(:label_for_search_field).and_return('Foo')
     end
 
     let(:search_params) { { q: 'Simon', search_field: 'publisher', controller: 'catalog' } }
     subject { helper.render_constraints_query(search_params) }
 
-    it "removes search_field" do
+    it 'removes search_field' do
       node = Capybara::Node::Simple.new(subject)
-      expect(node).to have_link 'Remove constraint Foo: Simon', href: '/'
+      expect(node).to have_link 'Remove constraint Foo: Simon', href: catalog_index_path
     end
   end
 end

data/spec/helpers/url_helper_spec.rb

@@ -5,18 +5,19 @@ describe CurationConcerns::UrlHelper do
     GenericWork.destroy_all
   end
   let(:profile) { ["{\"datastreams\":{}}"] }
-  let(:work) { FactoryGirl.create(:generic_work) }
+  let(:work) { create(:generic_work) }
   let(:document) { SolrDocument.new(work.to_solr) }
   subject { helper.url_for_document document }
 
-  it { should eq "/concern/generic_works/#{work.id}" }
-  it "should use the curation_concern namespace" do
+  it { is_expected.to eq "/concern/generic_works/#{work.id}" }
+
+  it 'uses the curation_concern namespace' do
     expect(helper.url_for_document document).to eq "/concern/generic_works/#{work.id}"
   end
-  context "when document is a GenericFile" do
-    let(:file) { FactoryGirl.create(:generic_file) }
+
+  context 'when document is a FileSet' do
+    let(:file) { create(:file_set) }
     subject { helper.url_for_document file }
-    it { should eq "/concern/generic_files/#{file.id}" }
+    it { is_expected.to eq "/concern/file_sets/#{file.id}" }
   end
 end
-

data/spec/indexers/collection_indexer_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe CurationConcerns::CollectionIndexer do
+  let(:indexer) { described_class.new(collection) }
+  let(:collection) { build(:collection) }
+
+  describe "#generate_solr_document" do
+    subject { indexer.generate_solr_document }
+
+    it "has generic type" do
+      expect(subject.fetch('generic_type_sim')).to eq ["Collection"]
+    end
+  end
+end

data/spec/indexers/file_set_indexing_service_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe CurationConcerns::FileSetIndexingService do
+  let(:file_set) do
+    FileSet.new(
+      id: 'foo123',
+      part_of: ['Arabiana'],
+      contributor: ['Mohammad'],
+      creator: ['Allah'],
+      title: ['The Work'],
+      description: ['The work by Allah'],
+      publisher: ['Vertigo Comics'],
+      date_created: ['1200-01-01'],
+      date_uploaded: Date.parse('2011-01-01'),
+      date_modified: Date.parse('2012-01-01'),
+      subject: ['Theology'],
+      language: ['Arabic'],
+      rights: ['Wide open, buddy.'],
+      resource_type: ['Book'],
+      identifier: ['urn:isbn:1234567890'],
+      based_near: ['Medina, Saudi Arabia'],
+      related_url: ['http://example.org/TheWork/'],
+      mime_type: 'image/jpeg',
+      format_label: ['JPEG Image']) do |gf|
+        gf.full_text.content = 'abcxyz'
+        gf.height = ['500']
+        gf.width = ['600']
+      end
+  end
+
+  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')
+    end
+    subject { described_class.new(file_set).generate_solr_document }
+
+    it 'has fields' do
+      expect(subject[Solrizer.solr_name('hasRelatedMediaFragment', :symbol)]).to eq 'foo123'
+      expect(subject[Solrizer.solr_name('part_of')]).to be_nil
+      expect(subject[Solrizer.solr_name('date_uploaded')]).to be_nil
+      expect(subject[Solrizer.solr_name('date_modified')]).to be_nil
+      expect(subject[Solrizer.solr_name('date_uploaded', :stored_sortable, type: :date)]).to eq '2011-01-01T00:00:00Z'
+      expect(subject[Solrizer.solr_name('date_modified', :stored_sortable, type: :date)]).to eq '2012-01-01T00:00:00Z'
+      expect(subject[Solrizer.solr_name('rights')]).to eq ['Wide open, buddy.']
+      expect(subject[Solrizer.solr_name('related_url')]).to eq ['http://example.org/TheWork/']
+      expect(subject[Solrizer.solr_name('contributor')]).to eq ['Mohammad']
+      expect(subject[Solrizer.solr_name('creator')]).to eq ['Allah']
+      expect(subject[Solrizer.solr_name('title')]).to eq ['The Work']
+      expect(subject[Solrizer.solr_name('title', :facetable)]).to eq ['The Work']
+      expect(subject[Solrizer.solr_name('label')]).to eq 'CastoriaAd.tiff'
+      expect(subject[Solrizer.solr_name('label', :stored_sortable)]).to eq 'CastoriaAd.tiff'
+      expect(subject[Solrizer.solr_name('description')]).to eq ['The work by Allah']
+      expect(subject[Solrizer.solr_name('publisher')]).to eq ['Vertigo Comics']
+      expect(subject[Solrizer.solr_name('subject')]).to eq ['Theology']
+      expect(subject[Solrizer.solr_name('language')]).to eq ['Arabic']
+      expect(subject[Solrizer.solr_name('date_created')]).to eq ['1200-01-01']
+      expect(subject[Solrizer.solr_name('resource_type')]).to eq ['Book']
+      expect(subject[Solrizer.solr_name('file_format')]).to eq 'jpeg (JPEG Image)'
+      expect(subject[Solrizer.solr_name('identifier')]).to eq ['urn:isbn:1234567890']
+      expect(subject[Solrizer.solr_name('based_near')]).to eq ['Medina, Saudi Arabia']
+      expect(subject.fetch('mime_type_ssi')).to eq 'image/jpeg'
+      expect(subject.fetch('thumbnail_path_ss')).to eq '/downloads/foo123?file=thumbnail'
+      expect(subject['all_text_timv']).to eq('abcxyz')
+      expect(subject['height_is']).to eq 500
+      expect(subject['width_is']).to eq 600
+    end
+  end
+end

data/spec/indexers/generic_work_indexing_service_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe CurationConcerns::WorkIndexingService 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) }
+  let(:service) { described_class.new(generic_work) }
+  let(:file) { generic_work.file_sets.first }
+
+  before do
+    allow(CurationConcerns::ThumbnailPathService).to receive(:call).and_return("/downloads/#{file.id}?file=thumbnail")
+    generic_work.representative_id = file.id
+  end
+
+  subject { service.generate_solr_document }
+
+  it 'indexes files' do
+    expect(subject['file_set_ids_ssim']).to eq generic_work.member_ids
+    expect(subject['generic_type_sim']).to eq ['Work']
+    expect(subject.fetch('thumbnail_path_ss')).to eq "/downloads/#{file.id}?file=thumbnail"
+  end
+end

data/spec/inputs/multifile_input_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'MultifileInput', type: :input do
+  class Foo
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+
+    def persisted?
+      false
+    end
+
+    attr_accessor :bar
+
+    def [](val)
+      raise "Unknown attribute" unless val == :bar
+      bar
+    end
+  end
+
+  let(:foo) { Foo.new }
+  let(:bar) { ["bar1", "bar2"] }
+  subject do
+    foo.bar = bar
+    input_for(foo, :files, as: :multifile)
+  end
+
+  it 'renders multifile' do
+    expect(subject).to have_selector('.form-group.multifile label[for=foo_files]', text: 'Upload a file')
+    expect(subject).to have_selector('.form-group.foo_files.multifile input[name="foo[files][]"]')
+  end
+end

data/spec/jobs/active_fedora_id_based_job_spec.rb

@@ -1,14 +1,16 @@
 require 'spec_helper'
 
 describe ActiveFedoraIdBasedJob do
-  let (:user) {FactoryGirl.find_or_create(:jill)}
-  let (:file) {GenericFile.new.tap do |gf|
-                  gf.apply_depositor_metadata(user)
-                  gf.save!
-                end}
+  let(:file_set) { FileSet.new }
+  let(:file_set_id) { 'abc123' }
 
-  it "finds object" do
-    job = ActiveFedoraIdBasedJob.new(file.id)
-    expect(job.generic_file).to_not be_nil
+  before do
+    allow(ActiveFedora::Base).to receive(:find).with(file_set_id).and_return(file_set)
+  end
+
+  it 'finds object' do
+    job = described_class.new
+    job.id = file_set_id
+    expect(job.file_set).to eq file_set
   end
 end

data/spec/jobs/audit_job_spec.rb

@@ -1,51 +1,59 @@
 require 'spec_helper'
 
 describe AuditJob do
-  let(:user) { FactoryGirl.create(:user) }
+  let(:user) { create(:user) }
 
   let(:file) do
-    generic_file = GenericFile.create do |file|
+    FileSet.create do |file|
       file.apply_depositor_metadata(user)
-      Hydra::Works::AddFileToGenericFile.call(file, File.open(fixture_file_path('world.png')), :original_file, versioning: true)
+      Hydra::Works::AddFileToFileSet.call(file, File.open(fixture_file_path('world.png')), :original_file, versioning: true)
     end
   end
   let(:file_id) { file.original_file.id }
 
-  let(:job) { AuditJob.new(file.id, file_id, uri) }
+  let(:job) { described_class.perform_now(file.id, file_id, uri) }
 
-  describe "audit on content" do
+  describe 'audit on content' do
     let(:uri) { file.original_file.uri }
-    it "should pass" do
-      expect(job.run).to eq(true)
+    it 'passes' do
+      expect(job).to eq(true)
     end
   end
 
-  describe "audit on a version of the content" do
+  describe 'audit on a version of the content' do
     let(:uri) { CurationConcerns::VersioningService.latest_version_of(file.original_file).uri }
-    it "should pass" do
-      expect(job.run).to eq(true)
+    it 'passes' do
+      expect(job).to eq(true)
     end
   end
 
-  describe "audit on an invalid version of the content" do
-    let(:uri) { CurationConcerns::VersioningService.latest_version_of(file.original_file).uri + "bogus" }
-    it "should fail" do
-      expect(job.run).to eq(false)
+  describe 'audit on an invalid version of the content' do
+    let(:uri) { CurationConcerns::VersioningService.latest_version_of(file.original_file).uri + 'bogus' }
+    it 'fails' do
+      expect(job).to eq(false)
     end
   end
 
-  describe "run_audit" do
+  describe 'run_audit' do
     let(:uri) { CurationConcerns::VersioningService.latest_version_of(file.original_file).uri }
-    let!(:old) { ChecksumAuditLog.create(generic_file_id: file.id, file_id: file_id, version: uri, pass: 1, created_at: 2.minutes.ago) }
-    let!(:new) { ChecksumAuditLog.create(generic_file_id: file.id, file_id: file_id, version: uri, pass: 0) }
+    let!(:old) { ChecksumAuditLog.create(file_set_id: file.id, file_id: file_id, version: uri, pass: 1, created_at: 2.minutes.ago) }
+    let!(:new) { ChecksumAuditLog.create(file_set_id: file.id, file_id: file_id, version: uri, pass: 0) }
     let(:mock_service) { double('mock fixity check service') }
-  
+
     before do
       allow(ActiveFedora::FixityService).to receive(:new).and_return(mock_service)
       allow(mock_service).to receive(:check).and_return(true, false, false, true, false)
     end
-  
-    it "should not prune failed audits" do
+
+    let(:job) do
+      described_class.new.tap do |j|
+        j.id = file.id
+        j.file_id = file_id
+        j.uri = uri
+      end
+    end
+
+    it 'does not prune failed audits' do
       5.times { job.send(:run_audit) }
       expect(ChecksumAuditLog.logs_for(file.id, file_id).map(&:pass)).to eq [0, 1, 0, 0, 1, 0, 1]
     end

data/spec/jobs/characterize_job_spec.rb

@@ -1,23 +1,18 @@
 require 'spec_helper'
 
 describe CharacterizeJob do
-  let(:user) { FactoryGirl.find_or_create(:jill) }
+  let(:file_set) { FileSet.new(id: file_set_id) }
+  let(:file_set_id) { 'abc123' }
+  let(:filename) { double }
 
-  let(:generic_file) do
-    GenericFile.create do |file|
-      file.apply_depositor_metadata(user)
-      Hydra::Works::AddFileToGenericFile.call(file, File.open(fixture_file_path('charter.docx')), :original_file)
-    end
+  before do
+    allow(ActiveFedora::Base).to receive(:find).with(file_set_id).and_return(file_set)
   end
 
-  subject { CharacterizeJob.new(generic_file.id) }
-
-  # Now that CreateDerivativesJob calls generic_file.create_derivatives directly
-  # this test needs to be travis exempt.  
-  it 'runs CurationConcerns::CharacterizationService that spawns a CreateDerivativesJob', unless: $in_travis do
-    expect(CurationConcerns::CharacterizationService).to receive(:run).with(generic_file)
-    expect(CreateDerivativesJob).to receive(:new).with(generic_file.id).once.and_call_original
-    subject.run
+  it 'runs Hydra::Works::CharacterizationService and creates a CreateDerivativesJob' do
+    expect(Hydra::Works::CharacterizationService).to receive(:run).with(file_set, filename)
+    expect(file_set).to receive(:save)
+    expect(CreateDerivativesJob).to receive(:perform_later).with(file_set_id, filename)
+    described_class.perform_now file_set_id, filename
   end
-
 end