curation_concerns 0.1.0 → 0.2.0

data/spec/models/generic_file_spec.rb

@@ -1,619 +0,0 @@
-require 'spec_helper'
-
-# This tests the GenericFile model that is inserted into the host app by curation_concerns:models:install
-# It includes the CurationConcerns::GenericFileBehavior module and nothing else
-# So this test covers both the GenericFileBehavior module and the generated GenericFile model
-describe GenericFile do
-
-  let(:user) { FactoryGirl.find_or_create(:jill) }
-
-  describe "rdf type" do
-    subject { described_class.new.type }
-    it { is_expected.to include(RDFVocabularies::PCDMTerms.Object,WorksVocabularies::WorksTerms.GenericFile) }
-  end
-
-  it "is a Hydra::Works GenericFile" do
-    expect(subject).to be_works_generic_file
-  end
-
-  it "should have depositor" do
-    subject.depositor = 'tess@example.com'
-  end
-
-  it "should update attributes" do
-    subject.attributes = {title:["My new Title"]}
-    expect(subject.title).to eq(["My new Title"])
-  end
-
-  context "when it is initialized" do
-    it "has empty arrays for all the properties" do
-      subject.attributes.each do |k,v|
-        expect(Array(v)).to eq([])
-      end
-    end
-  end
-
-  describe "visibility" do
-    it "should not be changed when it's new" do
-      expect(subject).not_to be_visibility_changed
-    end
-    it "should be changed when it has been changed" do
-      subject.visibility= 'open'
-      expect(subject).to be_visibility_changed
-    end
-
-    it "should not be changed when it's set to its previous value" do
-      subject.visibility= 'restricted'
-      expect(subject).not_to be_visibility_changed
-    end
-
-  end
-
-  describe "#apply_depositor_metadata" do
-    before { subject.apply_depositor_metadata('jcoyne') }
-
-    it "should grant edit access and record the depositor" do
-      expect(subject.edit_users).to eq ['jcoyne']
-      expect(subject.depositor).to eq 'jcoyne'
-    end
-  end
-
-  describe "attributes" do
-    it "should have a set of permissions" do
-      subject.read_groups=['group1', 'group2']
-      subject.edit_users=['user1']
-      subject.read_users=['user2', 'user3']
-      expect(subject.permissions.map(&:to_hash)).to match_array [
-                                                                    {type: "group", access: "read", name: "group1"},
-                                                                    {type: "group", access: "read", name: "group2"},
-                                                                    {type: "person", access: "read", name: "user2"},
-                                                                    {type: "person", access: "read", name: "user3"},
-                                                                    {type: "person", access: "edit", name: "user1"}]
-    end
-
-    it "should have a characterization datastream" do
-      expect(subject.characterization).to be_kind_of FitsDatastream
-    end
-
-    it "should have attached content" do
-      subject.add_file(File.open(fixture_path + '/world.png'), path: 'content', original_name: 'world.png')
-      expect(subject.content).to be_kind_of ActiveFedora::File
-    end
-  end
-
-  describe "metadata" do
-    it "should have descriptive metadata" do
-      expect(subject).to respond_to(:relative_path)
-      expect(subject).to respond_to(:depositor)
-      expect(subject).to respond_to(:related_url)
-      expect(subject).to respond_to(:based_near)
-      expect(subject).to respond_to(:part_of)
-      expect(subject).to respond_to(:contributor)
-      expect(subject).to respond_to(:creator)
-      expect(subject).to respond_to(:title)
-      expect(subject).to respond_to(:description)
-      expect(subject).to respond_to(:publisher)
-      expect(subject).to respond_to(:date_created)
-      expect(subject).to respond_to(:date_uploaded)
-      expect(subject).to respond_to(:date_modified)
-      expect(subject).to respond_to(:subject)
-      expect(subject).to respond_to(:language)
-      expect(subject).to respond_to(:rights)
-      expect(subject).to respond_to(:resource_type)
-      expect(subject).to respond_to(:identifier)
-    end
-    it "should delegate methods to characterization metadata" do
-      expect(subject).to respond_to(:format_label)
-      expect(subject).to respond_to(:mime_type)
-      expect(subject).to respond_to(:file_size)
-      expect(subject).to respond_to(:last_modified)
-      expect(subject).to respond_to(:filename)
-      expect(subject).to respond_to(:original_checksum)
-      expect(subject).to respond_to(:well_formed)
-      expect(subject).to respond_to(:file_title)
-      expect(subject).to respond_to(:file_author)
-      expect(subject).to respond_to(:page_count)
-    end
-    it "should redefine to_param to make redis keys more recognizable" do
-      expect(subject.to_param).to eq subject.id
-    end
-
-    describe "that have been saved" do
-      before { subject.apply_depositor_metadata('jcoyne') }
-
-      it "should be able to set values via delegated methods" do
-        subject.related_url = ["http://example.org/"]
-        subject.creator = ["John Doe"]
-        subject.title = ["New work"]
-        subject.save
-        f = subject.reload
-        expect(f.related_url).to eq ["http://example.org/"]
-        expect(f.creator).to eq ["John Doe"]
-        expect(f.title).to eq ["New work"]
-      end
-
-      it "should be able to be added to w/o unexpected graph behavior" do
-        subject.creator = ["John Doe"]
-        subject.title = ["New work"]
-        subject.save!
-        f = subject.reload
-        expect(f.creator).to eq ["John Doe"]
-        expect(f.title).to eq ["New work"]
-        f.creator = ["Jane Doe"]
-        f.title += ["Newer work"]
-        f.save
-        f = subject.reload
-        expect(f.creator).to eq ["Jane Doe"]
-        # TODO: Is order important?
-        expect(f.title).to include("New work")
-        expect(f.title).to include("Newer work")
-      end
-    end
-  end
-
-  describe "#indexer" do
-    subject { described_class.indexer }
-    it { is_expected.to eq CurationConcerns::GenericFileIndexingService }
-  end
-
-  it "should support multi-valued fields in solr" do
-    subject.tag = ["tag1", "tag2"]
-    expect { subject.save }.not_to raise_error
-    subject.delete
-  end
-
-  it "should support setting and getting the relative_path value" do
-    subject.relative_path = "documents/research/NSF/2010"
-    expect(subject.relative_path).to eq "documents/research/NSF/2010"
-  end
-  describe "create_thumbnail" do
-    before do
-      @f = GenericFile.new
-      @f.apply_depositor_metadata('mjg36')
-    end
-    describe "with a video", if: CurationConcerns.config.enable_ffmpeg do
-      before do
-        allow(@f).to receive(mime_type: 'video/quicktime')  #Would get set by the characterization job
-        @f.add_file(File.open("#{fixture_path}/countdown.avi", 'rb'), path: 'content', original_name: 'countdown.avi')
-        @f.save
-      end
-      it "should make a png thumbnail" do
-        @f.create_thumbnail
-        expect(@f.thumbnail.content.size).to eq 4768 # this is a bad test. I just want to show that it did something.
-        expect(@f.thumbnail.mime_type).to eq 'image/png'
-      end
-    end
-  end
-
-  describe "#related_files" do
-    let!(:f1)   { GenericFile.new }
-
-    context "when there are no related files" do
-      it "should return an empty array" do
-        expect(f1.related_files).to eq []
-      end
-    end
-
-    context "when there are related files" do
-      let(:parent_work)   { FactoryGirl.create(:work_with_files)}
-      let(:f1)            { parent_work.generic_files.first }
-      let(:f2)            { parent_work.generic_files.last }
-      subject { f1.reload.related_files }
-      it "returns all generic_files contained in parent work(s) but excludes itself" do
-        expect(subject).to include(f2)
-        expect(subject).to_not include(f1)
-      end
-    end
-  end
-
-  describe "noid integration" do
-    before do
-      allow_any_instance_of(ActiveFedora::Noid::Service).to receive(:mint).and_return(noid)
-    end
-
-    let(:noid) { 'wd3763094' }
-
-    subject do
-      GenericFile.create { |f| f.apply_depositor_metadata('mjg36') }
-    end
-
-    it "runs the overridden #assign_id method" do
-      expect_any_instance_of(ActiveFedora::Noid::Service).to receive(:mint).once
-      GenericFile.create { |f| f.apply_depositor_metadata('mjg36') }
-    end
-
-    it "returns the expected identifier" do
-      expect(subject.id).to eq noid
-    end
-
-    it "has a treeified URL" do
-      expect(subject.uri).to eq 'http://localhost:8983/fedora/rest/test/wd/37/63/09/wd3763094'
-    end
-
-    context "when a url is provided" do
-      let(:url) { 'http://localhost:8983/fedora/rest/test/wd/37/63/09/wd3763094' }
-
-      it "transforms the url into an id" do
-        expect(GenericFile.uri_to_id(url)).to eq 'wd3763094'
-      end
-    end
-  end
-
-  context "with access control metadata" do
-    subject do
-      GenericFile.new do |m|
-        m.apply_depositor_metadata('jcoyne')
-        m.permissions_attributes = [{type: 'person', access: 'read', name: "person1"},
-                                    {type: 'person', access: 'read', name: "person2"},
-                                    {type: 'group', access: 'read', name: "group-6"},
-                                    {type: 'group', access: 'read', name: "group-7"},
-                                    {type: 'group', access: 'edit', name: "group-8"}]
-      end
-    end
-
-    it "should have read groups accessor" do
-      expect(subject.read_groups).to eq ['group-6', 'group-7']
-    end
-
-    it "should have read groups string accessor" do
-      expect(subject.read_groups_string).to eq 'group-6, group-7'
-    end
-
-    it "should have read groups writer" do
-      subject.read_groups = ['group-2', 'group-3']
-      expect(subject.read_groups).to eq ['group-2', 'group-3']
-    end
-
-    it "should have read groups string writer" do
-      subject.read_groups_string = 'umg/up.dlt.staff, group-3'
-      expect(subject.read_groups).to eq ['umg/up.dlt.staff', 'group-3']
-      expect(subject.edit_groups).to eq ['group-8']
-      expect(subject.read_users).to eq ['person1', 'person2']
-      expect(subject.edit_users).to eq ['jcoyne']
-    end
-
-    it "should only revoke eligible groups" do
-      subject.set_read_groups(['group-2', 'group-3'], ['group-6'])
-      # 'group-7' is not eligible to be revoked
-      expect(subject.read_groups).to match_array ['group-2', 'group-3', 'group-7']
-      expect(subject.edit_groups).to eq ['group-8']
-      expect(subject.read_users).to match_array ['person1', 'person2']
-      expect(subject.edit_users).to eq ['jcoyne']
-    end
-  end
-
-  describe "permissions validation" do
-    before { subject.apply_depositor_metadata('mjg36') }
-
-    describe "overriding" do
-      let(:asset) { SampleKlass.new }
-      before do
-        class SampleKlass < GenericFile
-          def paranoid_edit_permissions
-            []
-          end
-        end
-        asset.apply_depositor_metadata('mjg36')
-      end
-      after do
-        Object.send(:remove_const, :SampleKlass)
-      end
-      context "when the public has edit access" do
-        before { subject.edit_groups = ['public'] }
-
-        it "should be invalid" do
-          expect(subject).to_not be_valid
-          expect(subject.errors[:edit_groups]).to include('Public cannot have edit access')
-        end
-      end
-    end
-
-    context "when the depositor does not have edit access" do
-      before do
-        subject.permissions = [ Hydra::AccessControls::Permission.new(type: 'person', name: 'mjg36', access: 'read')]
-      end
-      it "should be invalid" do
-        expect(subject).to_not be_valid
-        expect(subject.errors[:edit_users]).to include('Depositor must have edit access')
-      end
-    end
-
-    context "when the public has edit access" do
-      before { subject.edit_groups = ['public'] }
-
-      it "should be invalid" do
-        expect(subject).to_not be_valid
-        expect(subject.errors[:edit_groups]).to include('Public cannot have edit access')
-      end
-    end
-
-    context "when registered has edit access" do
-      before { subject.edit_groups = ['registered'] }
-
-      it "should be invalid" do
-        expect(subject).to_not be_valid
-        expect(subject.errors[:edit_groups]).to include('Registered cannot have edit access')
-      end
-    end
-
-    context "everything is copacetic" do
-      it "should be valid" do
-        expect(subject).to be_valid
-      end
-    end
-  end
-
-  describe "file content validation" do
-    subject                       { FactoryGirl.create(:generic_file) }
-    let(:file_path)         { fixture_path + '/small_file.txt' }
-
-    context "when file contains a virus" do
-      before do
-        allow(subject).to receive(:warn) # suppress virus warnings
-        expect(ClamAV.instance).to receive(:scanfile).and_return("EL CRAPO VIRUS")
-        # TODO: Test that this works with Hydra::Works::UploadFileToGenericFile. see https://github.com/projecthydra-labs/hydra-works/pull/139
-        # Hydra::Works::UploadFileToGenericFile.call(subject, file_path, original_name: 'small_file.txt')
-        of = subject.build_original_file
-        of.content = File.open(file_path)
-      end
-
-      it "populates the errors hash during validation" do
-        expect(subject).to_not be_valid
-        expect(subject.errors.messages[:base].first).to match /A virus was found in .*: EL CRAPO VIRUS/
-      end
-
-      it "does not save the file or create a new version" do
-        original_version_count = subject.versions.count
-        subject.save
-        expect(subject.versions.count).to eq original_version_count
-        expect(subject.reload.original_file).to be_nil
-      end
-    end
-  end
-
-  describe "to_solr" do
-    before do
-      subject.title = ['One Flew Over the Cuckoo\'s Nest']
-      subject.characterization.height = '500'
-      subject.characterization.width = '600'
-    end
-    let(:solr_doc) { subject.to_solr }
-
-    it "has a solr_doc" do
-      expect(solr_doc['title_tesim']).to eq ['One Flew Over the Cuckoo\'s Nest']
-      expect(solr_doc['title_sim']).to eq ['One Flew Over the Cuckoo\'s Nest']
-      expect(solr_doc['height_isi']).to eq 500
-      expect(solr_doc['width_isi']).to eq 600
-    end
-  end
-
-  context "with versions" do
-    it "should have versions" do
-      expect(subject.versions.count).to eq 0
-    end
-  end
-
-  describe "public?" do
-    context "when read group is set to public" do
-      before { subject.read_groups = ['public'] }
-
-      it { is_expected.to be_public }
-    end
-
-    context "when read group is not set to public" do
-      before { subject.read_groups = ['foo'] }
-      it { is_expected.not_to be_public }
-    end
-  end
-
-  describe "work associations" do
-    let(:work) { FactoryGirl.create(:work_with_one_file) }
-    subject { work.generic_files.first.reload }
-    it "should belong to works" do
-      expect(subject.generic_works).to eq [work]
-    end
-  end
-
-  describe '#to_s' do
-    it 'uses the provided titles' do
-      subject.title = ["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 "to_solr record" do
-    let(:depositor) { 'jcoyne' }
-    subject do
-      GenericFile.new.tap do |f|
-        f.apply_depositor_metadata(depositor)
-        f.save
-      end
-    end
-    let(:depositor_key) { Solrizer.solr_name("depositor") }
-    let(:title_key) { Solrizer.solr_name("title", :stored_searchable, type: :string) }
-    let(:title) { ["abc123"] }
-    let(:no_terms) { GenericFile.find(subject.id).to_solr }
-    let(:terms) {
-      file = GenericFile.find(subject.id)
-      file.title = title
-      file.save
-      file.to_solr
-    }
-
-    context "without terms" do
-      specify "title is nil" do
-        expect(no_terms[title_key]).to be_nil
-      end
-    end
-
-    context "with terms" do
-      specify "depositor is set" do
-        expect(terms[depositor_key].first).to eql(depositor)
-      end
-      specify "title is set" do
-        expect(terms[title_key]).to eql(title)
-      end
-    end
-
-  end
-
-  describe "assign_id" do
-    context "with noids enabled (by default)" do
-      it "uses the noid service" do
-        expect_any_instance_of(ActiveFedora::Noid::Service).to receive(:mint).once
-        subject.assign_id
-      end
-    end
-
-    context "with noids disabled" do
-      before { CurationConcerns.config.enable_noids = false }
-      after { CurationConcerns.config.enable_noids = true }
-
-      it "does not use the noid service" do
-        expect_any_instance_of(ActiveFedora::Noid::Service).not_to receive(:mint)
-        subject.assign_id
-      end
-    end
-  end
-
-  describe 'with a parent work' do
-
-    let(:parent) { FactoryGirl.create(:work_with_one_file) }
-    let(:parent_id) { parent.id }
-
-    describe '#related_files' do
-      let(:parent) { FactoryGirl.create(:work_with_files) }
-      let(:sibling) { parent.generic_files.last }
-      subject { parent.generic_files.first.reload }
-      it "returns related files, but not itself" do
-        expect(subject.related_files).to eq([sibling])
-        expect(sibling.reload.related_files).to eq([subject])
-      end
-    end
-
-    describe '#remove_representative_relationship' do
-      let(:some_other_id) { 'something456' }
-      subject { parent.generic_files.first.reload }
-      context "the parent object doesn't exist" do
-        before do
-          parent.representative = subject.id
-          parent.save!
-          @parent_id = parent.id
-          parent.destroy
-        end
-      end
-
-      context 'it is not the representative' do
-        before do
-          parent.representative = some_other_id
-          parent.save!
-        end
-        it "doesn't update parent work when file is deleted" do
-          subject.destroy
-          expect(parent.representative).to eq some_other_id
-        end
-      end
-
-      context 'it is the representative' do
-        before do
-          parent.representative = subject.id
-          parent.save!
-        end
-        it 'updates the parent work when the file is deleted' do
-          subject.destroy
-          expect(parent.reload.representative).to be_nil
-        end
-      end
-    end
-  end
-
-  describe "mime type recognition" do
-    context "#image?" do
-      context "when image/jp2" do
-        before { subject.mime_type = 'image/jp2' }
-        it { should be_image }
-      end
-      context "when image/jpg" do
-        before { subject.mime_type = 'image/jpg' }
-        it { should be_image }
-      end
-      context "when image/png" do
-        before { subject.mime_type = 'image/png' }
-        it { should be_image }
-      end
-      context "when image/tiff" do
-        before { subject.mime_type = 'image/tiff' }
-        it { should be_image }
-      end
-    end
-
-    describe "#pdf?" do
-      before { subject.mime_type = 'application/pdf' }
-      it { should be_pdf }
-    end
-
-    describe "#audio?" do
-      context "when x-wave" do
-        before { subject.mime_type = 'audio/x-wave' }
-        it { should be_audio }
-      end
-      context "when x-wav" do
-        before { subject.mime_type = 'audio/x-wav' }
-        it { should be_audio }
-      end
-      context "when mpeg" do
-        before { subject.mime_type = 'audio/mpeg' }
-        it { should be_audio }
-      end
-      context "when mp3" do
-        before { subject.mime_type = 'audio/mp3' }
-        it { should be_audio }
-      end
-      context "when ogg" do
-        before { subject.mime_type = 'audio/ogg' }
-        it { should be_audio }
-      end
-    end
-
-    describe "#video?" do
-      context "should be true for avi" do
-        before { subject.mime_type = 'video/avi' }
-        it { should be_video }
-      end
-
-      context "should be true for webm" do
-        before { subject.mime_type = 'video/webm' }
-        it { should be_video }
-      end
-      context "should be true for mp4" do
-        before { subject.mime_type = 'video/mp4' }
-        it { should be_video }
-      end
-      context "should be true for mpeg" do
-        before { subject.mime_type = 'video/mpeg' }
-        it { should be_video }
-      end
-      context "should be true for quicktime" do
-        before { subject.mime_type = 'video/quicktime' }
-        it { should be_video }
-      end
-      context "should be true for mxf" do
-        before { subject.mime_type = 'application/mxf' }
-        it { should be_video }
-      end
-    end
-  end
-
-end

data/spec/presenters/curation_concerns/generic_file_presenter_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe CurationConcerns::GenericFilePresenter do
-
-  describe ".terms" do
-    it "should return a list" do
-      expect(described_class.terms).to eq([:resource_type, :title,
-                                           :creator, :contributor, :description, :tag, :rights, :publisher,
-                                           :date_created, :subject, :language, :identifier, :based_near,
-                                           :related_url])
-    end
-  end
-
-  let(:presenter) { CurationConcerns::GenericFilePresenter.new(file) }
-
-end

data/spec/services/characterization_service_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe CurationConcerns::CharacterizationService do
-  let(:generic_file) { FactoryGirl.create(:generic_file) }
-
-  describe "#run" do
-    let(:service_instance) { double() }
-    it "creates an instance of the service and calls .characterize on it" do
-      expect(described_class).to receive(:new).with(generic_file).and_return(service_instance)
-      expect(service_instance).to receive(:characterize)
-      described_class.run(generic_file)
-    end
-  end
-
-  # TODO: Enable in travis see https://github.com/projecthydra-labs/curation_concerns/issues/40
-  describe "characterize", unless: $in_travis do
-    subject   { described_class.new(generic_file) }
-    before do
-      Hydra::Works::UploadFileToGenericFile.call(generic_file, File.open(fixture_file_path('charter.docx')))
-    end
-    it "characterizes, extracts fulltext and stores the results" do
-      expect(subject).to receive(:extract_fulltext).and_return("The fulltext")
-      subject.characterize
-      expect(generic_file.mime_type).to eq 'application/vnd.oasis.opendocument.text'
-      expect(generic_file.filename).to eq 'charter.docx'
-      expect(generic_file.extracted_text.content).to eq "The fulltext"
-    end
-  end
-
-end

data/spec/services/full_text_extraction_service_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe CurationConcerns::FullTextExtractionService do
-  it "should do something useful" # It's not clear that this was working in Sufia before we pulled it into curation_concerns.  It hits a nonexistent URL on jetty to extract the text.
-end