curation_concerns 0.1.0 → 0.2.0

data/spec/controllers/curation_concerns/generic_files_controller_spec.rb

@@ -1,251 +0,0 @@
-require 'spec_helper'
-
-describe CurationConcerns::GenericFilesController do
-  let(:user) { FactoryGirl.create(:user) }
-  let(:file) { fixture_file_upload('files/image.png','image/png') }
-  let(:parent) { FactoryGirl.create(:generic_work, edit_users: [user.user_key], visibility:Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC) }
-
-  context "when signed in" do
-    before { sign_in user }
-
-    describe "#create" do
-      before do
-        GenericFile.destroy_all
-      end
-
-      context "on the happy path" do
-        let(:date_today) { DateTime.now }
-
-        before do
-          allow(DateTime).to receive(:now).and_return(date_today)
-        end
-
-        it "spawns a CharacterizeJob" do
-          s2 = double('one')
-          expect(CharacterizeJob).to receive(:new).and_return(s2)
-          expect(CurationConcerns.queue).to receive(:push).with(s2).once
-          expect {
-            xhr :post, :create, files: [file], parent_id: parent,
-              generic_file: { "title"=>["test title"],
-                              visibility: "restricted"}
-            expect(response).to be_success
-          }.to change { GenericFile.count }.by(1)
-          expect(flash[:error]).to be_nil
-          saved_file = assigns[:generic_file].reload
-
-          expect(saved_file.title).to eq ['test title']
-          expect(saved_file.label).to eq 'image.png'
-          expect(parent.reload.generic_files).to include saved_file
-          # Confirming that date_uploaded and date_modified were set
-          expect(saved_file.date_uploaded).to eq date_today.utc
-          expect(saved_file.date_modified).to eq date_today.utc
-          expect(saved_file.depositor).to eq user.email
-
-          expect(saved_file.original_file.versions.count).to eq(3)
-          expect(saved_file.original_file.versions.last).to be_instance_of(ActiveFedora::VersionsGraph::ResourceVersion)
-
-          # Confirm that embargo/lease are not set.
-          expect(saved_file).to_not be_under_embargo
-          expect(saved_file).to_not be_active_lease
-          expect(saved_file.visibility).to eq 'restricted'
-        end
-
-        it "copies visibility from the parent" do
-          s2 = double('one')
-          expect(CharacterizeJob).to receive(:new).and_return(s2)
-          allow(CurationConcerns.queue).to receive(:push).with(s2).once
-          xhr :post, :create, files: [file], parent_id: parent
-          expect(assigns[:generic_file]).to be_persisted
-          saved_file = assigns[:generic_file].reload
-          expect(saved_file.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-        end
-      end
-
-      context "on something that isn't a file" do
-        it "should render error" do
-          xhr :post, :create, files: ['hello'], parent_id: parent,
-               permission: { group: { 'public' => 'read' } }, terms_of_service: '1'
-          expect(response.status).to eq 422
-          err = JSON.parse(response.body).first['error']
-          expect(err).to match(/no file for upload/i)
-        end
-      end
-
-      context "when the file has a virus" do
-        it "displays a flash error" do
-          skip "pending hydra-works#89"
-          expect(CurationConcerns::GenericFileActor).to receive(:virus_check).with(file.path).and_raise(CurationConcerns::VirusFoundError.new('A virus was found'))
-          xhr :post, :create, files: [file], parent_id: parent,
-               permission: { group: { 'public' => 'read' } }, terms_of_service: '1'
-          expect(flash[:error]).to include('A virus was found')
-        end
-      end
-
-      context "when solr is down" do
-        it "should error out of create and save after on continuos rsolr error" do
-          allow_any_instance_of(GenericFile).to receive(:save).and_raise(RSolr::Error::Http.new({},{}))
-
-          xhr :post, :create, files: [file], parent_id: parent,
-               permission: { group: { 'public' => 'read' } }, terms_of_service: '1'
-          expect(response.body).to include("Error occurred while creating generic file.")
-        end
-      end
-
-    end
-
-    describe "destroy" do
-      let(:generic_file) do
-        generic_file = GenericFile.new.tap do |gf|
-          gf.apply_depositor_metadata(user)
-          gf.save!
-        end
-        parent.generic_files << generic_file
-        generic_file
-      end
-
-      it "should delete the file" do
-        expect(GenericFile.find(generic_file.id)).to be_kind_of GenericFile
-        delete :destroy, id: generic_file
-        expect { GenericFile.find(generic_file.id) }.to raise_error Ldp::Gone
-        expect(response).to redirect_to main_app.curation_concerns_generic_work_path(parent)
-      end
-    end
-
-    describe "update" do
-      let!(:generic_file) do
-        generic_file = GenericFile.new.tap do |gf|
-          gf.apply_depositor_metadata(user)
-          gf.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
-          gf.save!
-        end
-        parent.generic_files << generic_file
-        generic_file
-      end
-
-      after do
-        generic_file.destroy
-      end
-
-      context "updating metadata" do
-        it "should be successful and update attributes" do
-          post :update, id: generic_file, generic_file:
-            {title: ['new_title'], tag: [''], permissions_attributes: [{ type: 'person', name: 'archivist1', access: 'edit'}]}
-          expect(response).to redirect_to main_app.curation_concerns_generic_file_path(generic_file)
-          expect(assigns[:generic_file].title).to eq(['new_title'])
-        end
-
-        it "should go back to edit on an error" do
-          allow_any_instance_of(GenericFile).to receive(:valid?).and_return(false)
-          post :update, id: generic_file, generic_file:
-            {title: ['new_title'], tag: [''], permissions_attributes: [{ type: 'person', name: 'archivist1', access: 'edit'}]}
-          expect(response).to be_successful
-          expect(response).to render_template('edit')
-          expect(assigns[:generic_file]).to eq generic_file
-        end
-
-        it "should add a new groups and users" do
-          post :update, id: generic_file, generic_file:
-            { title: ['new_title'], tag: [''], permissions_attributes: [{ type: 'group', name: 'group1', access: 'read'}, { type: 'person', name: 'user1', access: 'edit'}]}
-
-          expect(assigns[:generic_file].read_groups).to eq ["group1"]
-          expect(assigns[:generic_file].edit_users).to include("user1")
-        end
-
-        it "should update existing groups and users" do
-          generic_file.read_groups = ['group3']
-          generic_file.save! # TODO slow , more than one save.
-          post :update, id: generic_file, generic_file:
-            { title: ['new_title'], tag: [''], permissions_attributes:[{ type: 'group', name: 'group3', access: 'edit'}] }
-          expect(assigns[:generic_file].edit_groups).to eq ["group3"]
-        end
-
-        context "updating visibility" do
-          it "should apply public" do
-            new_visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-            post :update, id: generic_file, generic_file: {visibility: new_visibility, embargo_release_date:""}
-            expect(generic_file.reload.visibility).to eq new_visibility
-          end
-
-          it "should apply embargo" do
-            post :update, id: generic_file, generic_file: {
-              visibility: 'embargo',
-              visibility_during_embargo: "restricted",
-              embargo_release_date: "2099-09-05",
-              visibility_after_embargo: "open",
-              visibility_during_lease: "open",
-              lease_expiration_date: "2099-09-05",
-              visibility_after_lease: "restricted"
-            }
-            generic_file.reload
-            expect(generic_file).to be_under_embargo
-            expect(generic_file).to_not be_active_lease
-          end
-        end
-      end
-
-      context "updating file content" do
-        it "should be successful" do
-          s2 = double('one')
-          expect(CharacterizeJob).to receive(:new).with(generic_file.id).and_return(s2)
-          expect(CurationConcerns.queue).to receive(:push).with(s2).once
-          post :update, id: generic_file, files: [file]
-          expect(response).to redirect_to main_app.curation_concerns_generic_file_path(generic_file)
-          skip "pending hydra-works#89"
-          expect(generic_file.reload.label).to eq 'image.png'
-        end
-      end
-
-      context "restoring an old version" do
-        before do
-          allow(CurationConcerns.queue).to receive(:push) # don't run characterization jobs
-          # Create version 1
-          Hydra::Works::AddFileToGenericFile.call(generic_file, File.open(fixture_file_path('small_file.txt')), :original_file)
-          # Create version 2
-          Hydra::Works::AddFileToGenericFile.call(generic_file, File.open(fixture_file_path('curation_concerns_generic_stub.txt')), :original_file)
-        end
-
-        it "should be successful" do
-          expect(generic_file.latest_content_version.label).to eq('version2')
-          expect(generic_file.original_file.content).to eq("This is a test fixture for curation_concerns: <%= @id %>.\n")
-          post :update, id: generic_file, revision: 'version1'
-          expect(response).to redirect_to main_app.curation_concerns_generic_file_path(generic_file)
-          reloaded = generic_file.reload.original_file
-          expect(reloaded.versions.last.label).to eq 'version3'
-          expect(reloaded.content).to eq "small\n"
-          expect(reloaded.mime_type).to eq 'text/plain'
-        end
-      end
-    end
-  end
-
-  context "someone elses files" do
-    let(:generic_file) do
-      generic_file = GenericFile.new.tap do |gf|
-        gf.apply_depositor_metadata('archivist1@example.com')
-        gf.read_groups = ['public']
-        gf.save!
-      end
-      parent.generic_files << generic_file
-      generic_file
-    end
-    after do
-      # GenericFile.find('curation_concerns:5').destroy
-    end
-    describe "edit" do
-      it "should give me a flash error" do
-        get :edit, id: generic_file
-        expect(response).to fail_redirect_and_flash(main_app.curation_concerns_generic_file_path(generic_file), 'You are not authorized to access this page.')
-      end
-    end
-    describe "view" do
-      it "should show me the file" do
-        get :show, id: generic_file
-        expect(response).to be_success
-      end
-    end
-    it "should not let the user submit if they logout" do
-      get :new, parent_id: parent
-      expect(response).to fail_redirect_and_flash(main_app.new_user_session_path, 'You are not authorized to access this page.')
-    end
-  end
-end

data/spec/forms/generic_file_edit_form_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe CurationConcerns::Forms::GenericFileEditForm do
-  subject { described_class.new(GenericFile.new) }
-
-  describe "#terms" do
-    it "should return 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])
-    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 "should initialize multivalued fields" do
-    expect(subject.title).to eq ['']
-  end
-
-  describe ".model_attributes" do
-    let(:params) { ActionController::Parameters.new(title: ['foo'], description: [''], "permissions_attributes"=>{"2"=>{"access"=>"edit", "_destroy"=>"true", "id"=>"a987551e-b87f-427a-8721-3e5942273125"}})}
-    subject { described_class.model_attributes(params) }
-
-    it "should only change title" do
-      expect(subject['title']).to eq ["foo"]
-      expect(subject['description']).to be_empty
-      expect(subject['permissions_attributes']).to eq("2" => {"access"=>"edit", "id"=>"a987551e-b87f-427a-8721-3e5942273125", "_destroy"=>"true"})
-    end
-  end
-
-end

data/spec/helpers/thumbnail_helper_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe CurationConcerns::ThumbnailHelper do
-  let(:work) { GenericWork.new }
-  let(:document) { SolrDocument.new work.to_solr }
-  subject { helper.thumbnail_tag document, {} }
-
-  context "with a representative" do
-    before do
-      allow(work).to receive(:representative).and_return('curation_concerns:test123')
-    end
-    it "draws the thumbnail" do
-      expect(subject).to eq "<img alt=\"Thumbnail\" class=\"canonical-image\" " \
-        "src=\"/downloads/curation_concerns:test123?datastream_id=thumbnail\" />"
-    end
-  end
-
-  it "draws the default thumbnail" do
-    expect(subject).to eq "<span class=\"canonical-image\"></span>"
-  end
-end

data/spec/jobs/copy_permissions_job_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe CopyPermissionsJob do
-
-  let(:user) { FactoryGirl.create(:user) }
-  context 'for valid pid' do
-    let(:generic_work) { FactoryGirl.create(:generic_work, user: user ) }
-    let(:another_user) { FactoryGirl.create(:user) }
-    let(:generic_file_1) { FactoryGirl.create(:generic_file, user: user) }
-    let(:generic_file_2) { FactoryGirl.create(:generic_file, user: user) }
-
-    before do
-      generic_work.edit_users += [another_user]
-      generic_work.generic_files = [generic_file_1, generic_file_2]
-      generic_work.save
-    end
-    subject { CopyPermissionsJob.new(generic_work.id) }
-
-    it 'applies group/editors permissions to attached files' do
-
-      expect(generic_work.generic_files).to eq [generic_file_1, generic_file_2]
-      expect(generic_work.edit_users).to eq [user.user_key, another_user.user_key]
-      expect(generic_file_1.edit_users).to eq [user.user_key]
-      expect(generic_file_2.edit_users).to eq [user.user_key]
-      generic_work.save
-
-      subject.run
-
-      generic_work.reload.generic_files.each do |file|
-        expect(file.edit_users).to eq [user.user_key, another_user.user_key]
-      end
-    end
-  end
-
-  describe "an open access work" do
-    let(:generic_work) { FactoryGirl.create(:work_with_files) }
-    subject { CopyPermissionsJob.new(generic_work.id) }
-
-    it "copies visibility to its contained files" do
-      generic_work.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-      generic_work.save
-      expect(generic_work.generic_files.first.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
-      subject.run
-      generic_work.reload.generic_files.each do |file|
-        expect(file.visibility).to eq 'open'
-      end
-    end
-  end
-end

data/spec/jobs/curation_concerns_resque_queue_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe CurationConcerns::Resque::Queue do
-  let(:subject) { CurationConcerns::Resque::Queue.new "test_queue" }
-  let(:job) { double('job') }
-
-  context "with no retries" do
-    it "queues the job" do
-      expect(::Resque).to receive(:enqueue_to).once.and_return(true)
-      subject.push(job)
-    end
-  end
-
-  context 'when one run times out' do
-    before do
-      call_count = 0
-      allow(::Resque).to receive(:enqueue_to) do
-        call_count += 1
-        call_count == 1 ? raise(Redis::TimeoutError) : true
-      end
-    end
-
-    it 'retries the job' do
-      expect(::Resque).to receive(:enqueue_to).twice
-      subject.push(job)
-    end
-  end
-
-  context 'when a job times out three times' do
-    before do
-      allow(::Resque).to receive(:enqueue_to).exactly(3).times.and_raise(Redis::TimeoutError)
-    end
-
-    it 'raises an error' do
-      expect { subject.push(job) }.to raise_error Redis::TimeoutError
-    end
-  end
-
-  context 'with no connection to Redis' do
-    before do
-      allow(::Resque).to receive(:enqueue_to).once.and_raise(Redis::CannotConnectError)
-    end
-
-    it 'logs an error' do
-      expect(ActiveFedora::Base.logger).to receive(:error).with("Redis is down!")
-      subject.push(job)
-    end
-  end
-end

data/spec/models/curation_concerns/generic_file/derivatives_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe CurationConcerns::GenericFile do
-
-  describe 'audiovisual transcoding' do
-    before do
-      file = File.open(File.join(fixture_path, file_name), 'r')
-      Hydra::Works::UploadFileToGenericFile.call(generic_file, file)
-      allow_any_instance_of(Hydra::Works::GenericFile::Base).to receive(:mime_type).and_return(mime_type)
-      generic_file.save!
-    end
-
-
-    context 'with a video (.avi) file', unless: $in_travis do
-      let(:mime_type) { 'video/avi' }
-      let(:file_name) { 'countdown.avi' }
-      let(:generic_file) { GenericFile.create { |gf| gf.apply_depositor_metadata('jcoyne@example.com') } }
-
-      it 'transcodes to webm and mp4' do
-        generic_file.create_derivatives
-        derivative = generic_file.webm
-        expect(derivative).not_to be_nil
-        expect(derivative.content).not_to be_nil
-        expect(derivative.mime_type).to eq('video/webm')
-
-        derivative2 = generic_file.mp4
-        expect(derivative2).not_to be_nil
-        expect(derivative2.content).not_to be_nil
-        expect(derivative2.mime_type).to eq('video/mp4')
-      end
-    end
-
-    context 'with an audio (.wav) file', unless: $in_travis do
-      let(:mime_type) { 'audio/wav' }
-      let(:file_name) { 'piano_note.wav' }
-      let(:generic_file) { GenericFile.create { |gf| gf.apply_depositor_metadata('jcoyne@example.com') } }
-
-      it 'transcodes to mp3 and ogg' do
-        generic_file.create_derivatives
-        derivative = generic_file.mp3
-        expect(derivative).not_to be_nil
-        expect(derivative.content).not_to be_nil
-        expect(derivative.mime_type).to eq('audio/mpeg')
-
-        derivative2 = generic_file.ogg
-        expect(derivative2).not_to be_nil
-        expect(derivative2.content).not_to be_nil
-        expect(derivative2.mime_type).to eq('audio/ogg')
-      end
-    end
-
-    context 'with an mp3 file', unless: $in_travis do
-      let(:mime_type) { 'audio/mpeg' }
-      let(:file_name) { 'test5.mp3' }
-      let(:generic_file) { GenericFile.create { |gf| gf.apply_depositor_metadata('jcoyne@example.com') } }
-
-      xit 'should copy the content to the mp3 datastream and transcode to ogg' do
-        generic_file.create_derivatives
-        derivative = generic_file.mp3
-
-        expect(derivative.size).to eq(generic_file.original_file.size)
-        expect(derivative.mime_type).to eq('audio/mpeg')
-        derivative2 = generic_file.ogg
-        expect(derivative2.content).not_to be_nil
-        expect(derivative2.mime_type).to eq('audio/ogg')
-      end
-    end
-
-    context 'with an ogg file', unless: $in_travis do
-      let(:mime_type) { 'audio/ogg' }
-      let(:file_name) { 'Example.ogg' }
-      let(:generic_file) { GenericFile.create { |gf| gf.apply_depositor_metadata('jcoyne@example.com') } }
-
-      xit 'should copy the content to the ogg datastream and transcode to mp3' do
-        generic_file.create_derivatives
-        derivative = generic_file.mp3
-        expect(derivative).not_to be_nil
-        expect(derivative.content).not_to be_nil
-        expect(derivative.mime_type).to eq('audio/mpeg')
-
-        derivative2 = generic_file.ogg
-        expect(derivative2).not_to be_nil
-        expect(derivative2.size).to eq(generic_file.original_file.size)
-        expect(derivative2.mime_type).to eq('audio/ogg')
-      end
-    end
-  end
-end

data/spec/models/curation_concerns/generic_work_behavior_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe CurationConcerns::GenericWorkBehavior do
-  before do
-    class EssentialWork < ActiveFedora::Base
-      include CurationConcerns::GenericWorkBehavior
-    end
-  end
-  after do
-    Object.send(:remove_const, :EssentialWork)
-  end
-
-  subject { EssentialWork.new }
-
-  it "should mix together all the goodness" do
-    [::CurationConcerns::WithGenericFiles, ::CurationConcerns::HumanReadableType, CurationConcerns::Noid, CurationConcerns::Serializers, Hydra::WithDepositor, Hydra::AccessControls::Embargoable, Solrizer::Common].each do |mixin|
-      expect(subject.class.ancestors).to include(mixin)
-    end
-  end
-
-  describe "human_readable_type" do
-    it "has a default" do
-      expect(subject.human_readable_type).to eq 'Essential Work'
-    end
-    it "should be settable" do
-      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
-end

data/spec/models/fits_datastream_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-describe FitsDatastream, type: :model, unless: $in_travis do
-  describe "image" do
-    before(:all) do
-      @file = GenericFile.create { |gf| gf.apply_depositor_metadata('blah') }
-      Hydra::Works::AddFileToGenericFile.call(@file, File.open(fixture_file_path('world.png')), :original_file)
-      CurationConcerns::CharacterizationService.run(@file)
-    end
-    it "has a format label" do
-      expect(@file.format_label).to eq ["Portable Network Graphics"]
-    end
-    it "has a mime type" do
-      expect(@file.mime_type).to eq "image/png"
-    end
-    it "has a file size" do
-      expect(@file.file_size).to eq ["4218"]
-    end
-    it "has a last modified timestamp" do
-      expect(@file.last_modified).to_not be_empty
-    end
-    it "has a filename" do
-      expect(@file.filename).to_not be_empty
-    end
-    it "has a checksum" do
-      expect(@file.original_checksum).to eq ["28da6259ae5707c68708192a40b3e85c"]
-    end
-    it "has a height" do
-      expect(@file.height).to eq ["50"]
-    end
-    it "has a width" do
-      expect(@file.width).to eq ["50"]
-    end
-
-    let(:datastream) { @file.characterization }
-    let(:xml) { datastream.ng_xml }
-    let(:namespace) { {'ns'=>'http://hul.harvard.edu/ois/xml/ns/fits/fits_output'} }
-
-    it "should make the fits XML" do
-      expect(xml.xpath('//ns:imageWidth/text()', namespace).inner_text).to eq '50'
-    end
-  end
-
-  describe "video" do
-    before(:all) do
-      @file = GenericFile.create { |gf| gf.apply_depositor_metadata('blah') }
-      Hydra::Works::AddFileToGenericFile.call(@file, File.open(fixture_file_path('sample_mpeg4.mp4')), :original_file)
-      CurationConcerns::CharacterizationService.run(@file)
-    end
-    it "has a format label" do
-      expect(@file.format_label).to eq ["ISO Media, MPEG v4 system, version 2"]
-    end
-    it "has a mime type" do
-      expect(@file.mime_type).to eq "video/mp4"
-    end
-    it "has a file size" do
-      expect(@file.file_size).to eq ["245779"]
-    end
-    it "has a last modified timestamp" do
-      expect(@file.last_modified).to_not be_empty
-    end
-    it "has a filename" do
-      expect(@file.filename).to_not be_empty
-    end
-    it "has a checksum" do
-      expect(@file.original_checksum).to eq ["dc77a8de8c091c19d86df74280f6feb7"]
-    end
-    it "has a width" do
-      expect(@file.width).to eq ["190"]
-    end
-    it "has a height" do
-      expect(@file.height).to eq ["240"]
-    end
-    it "has a sample_rate" do
-      expect(@file.sample_rate).to eq ["32000"]
-    end
-    it "has a duration" do
-      expect(@file.duration).to eq ["4.97 s"]
-    end
-    it "has a frame_rate" do
-      expect(@file.frame_rate.count).to eq 1
-      expect(@file.frame_rate[0].to_f).to eq 30.0
-    end
-  end
-
-  describe "pdf" do
-    before do
-      @myfile = GenericFile.create { |gf| gf.apply_depositor_metadata('blah') }
-      Hydra::Works::AddFileToGenericFile.call(@myfile, File.open(fixture_file_path('test4.pdf')), :original_file)
-      # characterize method saves
-      CurationConcerns::CharacterizationService.run(@myfile)
-    end
-
-    it "returns expected results after a save" do
-      expect(@myfile.file_size).to eq ['218882']
-      expect(@myfile.original_checksum).to eq ['5a2d761cab7c15b2b3bb3465ce64586d']
-
-      expect(@myfile.characterization_terms[:format_label]).to eq ["Portable Document Format"]
-      expect(@myfile.characterization_terms[:mime_type]).to eq "application/pdf"
-      expect(@myfile.characterization_terms[:file_size]).to eq ["218882"]
-      expect(@myfile.characterization_terms[:original_checksum]).to eq ["5a2d761cab7c15b2b3bb3465ce64586d"]
-      expect(@myfile.characterization_terms.keys).to include(:last_modified, :filename)
-
-      expect(@myfile.title).to include("Microsoft Word - sample.pdf.docx")
-      expect(@myfile.filename).to eq 'test4.pdf'
-
-      expect(@myfile.format_label).to eq ["Portable Document Format"]
-      expect(@myfile.title).to include("Microsoft Word - sample.pdf.docx")
-      expect(@myfile.extracted_text.content).to eq("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nMicrosoft Word - sample.pdf.docx\n\n\n \n \n\n \n\n \n\n \n\nThis PDF file was created using CutePDF. \n\nwww.cutepdf.com")
-    end
-  end
-
-  describe "m4a" do
-    before do
-      @myfile = GenericFile.create { |gf| gf.apply_depositor_metadata('blah') }
-      Hydra::Works::AddFileToGenericFile.call(@myfile, File.open(fixture_file_path('spoken-text.m4a')), :original_file)
-      # characterize method saves
-      CurationConcerns::CharacterizationService.run(@myfile)
-    end
-
-    it "returns expected content for full text" do
-      expect(@myfile.extracted_text.content).to eq("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nLavf56.15.102")
-    end
-  end
-
-
-end