curation_concerns 0.1.0

data/spec/jobs/curation_concerns_resque_queue_spec.rb

@@ -0,0 +1,49 @@
+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/jobs/import_url_job_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe ImportUrlJob do
+  let(:user) { FactoryGirl.find_or_create(:jill) }
+
+  let(:file_path) {  fixture_path + '/world.png' }
+  let(:file_hash)  {'/673467823498723948237462429793840923582'}
+
+  let(:generic_file) do
+    GenericFile.create do |f|
+      f.import_url = "http://example.org#{file_hash}"
+      f.label = file_path
+      f.apply_depositor_metadata(user.user_key)
+    end
+  end
+
+  let(:mock_response) do
+    double('response').tap do |http_res|
+      allow(http_res).to receive(:start).and_yield
+      allow(http_res).to receive(:content_type).and_return('image/png')
+      allow(http_res).to receive(:read_body).and_yield(File.open(File.expand_path(file_path, __FILE__)).read)
+    end
+  end
+
+  subject(:job) { ImportUrlJob.new(generic_file.id) }
+
+  it "should have no content at the outset" do
+    expect(generic_file.original_file).to be_nil
+  end
+
+  context "after running the job" do
+    before do
+      s1 = double('characterize')
+      allow(CharacterizeJob).to receive(:new).with(generic_file.id).and_return(s1)
+      expect(CurationConcerns.queue).to receive(:push).with(s1).once
+      expect(ClamAV.instance).to receive(:scanfile).and_return(0)
+    end
+
+    it "should create a content datastream" do
+      expect_any_instance_of(Net::HTTP).to receive(:request_get).with(file_hash).and_yield(mock_response)
+      job.run
+      expect(generic_file.reload.original_file.size).to eq 4218
+    end
+  end
+end

data/spec/jobs/ingest_local_file_job_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe IngestLocalFileJob do
+  let(:user) { FactoryGirl.find_or_create(:jill) }
+
+  let(:generic_file) do
+    GenericFile.create do |file|
+      file.apply_depositor_metadata(user)
+    end
+  end
+  
+  let(:job) { IngestLocalFileJob.new(generic_file.id, mock_upload_directory, "world.png", user.user_key) }
+  let(:mock_upload_directory) { 'spec/mock_upload_directory' }
+  
+  before do
+    Dir.mkdir mock_upload_directory unless File.exists? mock_upload_directory
+    FileUtils.copy(File.expand_path('../../fixtures/world.png', __FILE__), mock_upload_directory)
+  end
+  
+  it "should have attached a file" do
+    expect(CurationConcerns::CharacterizationService).to receive(:run).with(generic_file)
+    job.run
+    expect(generic_file.reload.original_file.size).to eq(4218)
+  end
+end

data/spec/lib/curation_concerns/messages_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe CurationConcerns::Messages do
+
+  let(:message) do
+    TestClass.new
+  end
+
+  before do
+    class TestClass
+      include CurationConcerns::Messages
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :TestClass)
+  end
+
+  let(:batch_id) { "1" }
+  let(:single) { double(to_param: "1", to_s: "File 1") }
+  let(:multiple) { [double(to_param: "1", to_s: "File 1"), double(to_param: "2", to_s: "File 2"), double(to_param: "3", to_s: "File 3")] }
+  let(:file_list) { "<a href='/concern/generic_files/1'>File 1</a>, <a href='/concern/generic_files/2'>File 2</a>, <a href='/concern/generic_files/3'>File 3</a>" }
+
+  describe "message subjects" do
+    it "should provide a subject for a success message" do
+      expect(message.success_subject).to eq("Batch upload complete")
+    end
+    it "should provide a subject for a failure message" do
+      expect(message.failure_subject).to eq("Batch upload permission denied")
+    end
+  end
+
+  describe "#single_success" do
+    it "should render a success message for a single file" do
+      node = Capybara::Node::Simple.new(message.single_success(batch_id, single))
+      expect(node).to have_selector("span[id=\"ss-1\"]", text:"File 1 has been saved.")
+      expect(node).to have_selector("a[href=\"/concern/generic_files/1\"]")
+    end
+  end
+
+  describe "#multiple_success" do
+    it "should render a success message for multiple files" do
+      node = Capybara::Node::Simple.new(message.multiple_success(batch_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\"]")
+    end
+  end
+
+  describe "#single_failure" do
+    it "should render a failure message for a single file" do
+      node = Capybara::Node::Simple.new(message.single_failure(batch_id, single))
+      expect(node).to have_selector("span[id=\"ss-1\"]", text:"File 1 could not be updated. You do not have sufficient privileges to edit it.")
+      expect(node).to have_selector("a[href=\"/concern/generic_files/1\"]")
+    end
+  end
+
+  describe "#multiple_failure" do
+    it "should render a failure message for multiple files" do
+      node = Capybara::Node::Simple.new(message.multiple_failure(batch_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\"]")
+    end
+  end
+
+  describe "#file_list" do
+    it "should replace double-quotes with single quotes" do
+      expect(message.file_list(multiple)).to eq(file_list)
+    end
+  end
+end

data/spec/lib/curation_concerns/readable_permissions_spec.rb

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

data/spec/lib/curation_concerns/writable_permissions_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe CurationConcerns::Permissions::Writable do
+
+  class SampleModel < ActiveFedora::Base
+    include CurationConcerns::Permissions::Writable
+  end
+  let(:subject) { SampleModel.new }
+
+  describe "#permissions" do
+    it "should initialize with nothing specified" do
+      expect(subject.permissions).to be_empty
+    end
+  end
+
+end

data/spec/matchers/metadata_field_matchers.rb

@@ -0,0 +1,28 @@
+# RSpec matcher to spec delegations.
+
+RSpec::Matchers.define :have_unique_field do |expected_field_name|
+  match do |subject|
+    expect(subject).to respond_to(expected_field_name)
+    field_value = subject.send(expected_field_name)
+    field_value.nil? || !field_value.kind_of?(Array)
+  end
+
+  description do
+    "expected to have a single-valued field named #{expected_field_name}"
+  end
+
+  failure_message_for_should do |subject|
+    "#{subject.inspect} should respond to #{expected_field_name} as a single-value, not an Array. Responded with #{subject.send(expected_field_name).inspect}"
+  end
+end
+
+RSpec::Matchers.define :have_multivalue_field do |expected_field_name|
+  match do |subject|
+    expect(subject).to respond_to(expected_field_name)
+    expect(subject.send(expected_field_name)).to be_instance_of Array
+  end
+
+  description do
+    "expected to have a multi-valued field named #{expected_field_name}"
+  end
+end

data/spec/matchers/response_matchers.rb

@@ -0,0 +1,7 @@
+RSpec::Matchers.define :fail_redirect_and_flash do |path,flash_message|
+  match do |response|
+    expect(response.status).to eq 302
+    expect(response).to redirect_to(path)
+    expect(flash[:alert]).to eq flash_message
+  end
+end

data/spec/matchers.rb

@@ -0,0 +1,24 @@
+require 'rspec/matchers'
+
+if defined?($SHOW_MATCHERS)
+  module RSpec::Shim
+    def define(matcher_name, *args, &block)
+      $SHOW_MATCHERS[matcher_name] = caller.first.split(":")[0..1]
+      super
+    end
+    def matcher(matcher_name, *args, &block)
+      $SHOW_MATCHERS[matcher_name] = caller.first.split(":")[0..1]
+      super
+    end
+  end
+
+  RSpec::Matchers.extend(RSpec::Shim)
+end
+
+require 'rspec/matchers/dsl'
+require 'rspec-html-matchers'
+require 'rspec-rails'
+require 'rspec/rails'
+require 'rspec/rails/matchers'
+
+Dir[File.expand_path('../matchers/**/*.rb', __FILE__)].each { |f| require f }

data/spec/models/checksum_audit_log_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe ChecksumAuditLog do
+  before do
+    # stub out characterization so it does not get audited
+    allow_any_instance_of(CurationConcerns::CharacterizationService).to receive(:characterize)
+  end
+
+  let(:f) do
+    GenericFile.create do |gf|
+      gf.add_file(File.open(fixture_path + '/world.png'), path: 'content', original_name: 'world.png')
+      gf.apply_depositor_metadata('mjg36')
+    end
+  end
+
+  let(:version_uri) { CurationConcerns::VersioningService.create(f.content); f.content.versions.first.uri }
+  let(:content_id) { f.content.id }
+  let(:old) { ChecksumAuditLog.create(generic_file_id: f.id, file_id: content_id, version: version_uri, pass: 1, created_at: 2.minutes.ago) }
+  let(:new) { ChecksumAuditLog.create(generic_file_id: f.id, file_id: content_id, version: version_uri, pass: 0, created_at: 1.minute.ago) }
+
+  context "a file with multiple checksums audits" do
+    specify "should return a list of logs for this datastream sorted by date descending" do
+      logs = ChecksumAuditLog.logs_for(f.id, content_id)
+      expect(logs).to eq([new, old])
+    end
+  end
+
+  context "after multiple checksum audits where the checksum does not change" do
+    specify "only one of them should be kept" do
+      success1 = ChecksumAuditLog.create(generic_file_id: f.id, file_id: content_id, version: version_uri, pass: 1)
+      ChecksumAuditLog.prune_history(f.id, content_id)
+      success2 = ChecksumAuditLog.create(generic_file_id: f.id, file_id: content_id, version: version_uri, pass: 1)
+      ChecksumAuditLog.prune_history(f.id, content_id)
+      success3 = ChecksumAuditLog.create(generic_file_id: f.id, file_id: content_id, version: version_uri, pass: 1)
+      ChecksumAuditLog.prune_history(f.id, content_id)
+
+      expect { ChecksumAuditLog.find(success2.id) }.to raise_exception ActiveRecord::RecordNotFound
+      expect { ChecksumAuditLog.find(success3.id) }.to raise_exception ActiveRecord::RecordNotFound
+      expect(ChecksumAuditLog.find(success1.id)).not_to be_nil
+      logs = ChecksumAuditLog.logs_for(f.id, content_id)
+      expect(logs).to eq([success1, new, old])
+    end
+  end
+
+  context "should have an audit log history" do
+    before do
+      ChecksumAuditLog.create(generic_file_id: f.id, file_id: f.content.id, version: 'v2', pass: 1)
+      ChecksumAuditLog.create(generic_file_id: f.id, file_id: 'thumbnail', version: 'v1', pass: 1)
+    end
+
+    it "has an audit log history" do
+      audit = ChecksumAuditLog.get_audit_log(f.id, f.content.id, version_uri)
+      expect(audit.generic_file_id).to eq(f.id)
+      expect(audit.version).to eq(version_uri)
+
+      audit = ChecksumAuditLog.get_audit_log(f.id, f.content.id, 'v2')
+      expect(audit.generic_file_id).to eq(f.id)
+      expect(audit.version).to eq('v2')
+
+      audit = ChecksumAuditLog.get_audit_log(f.id, 'thumbnail', 'v1')
+      expect(audit.generic_file_id).to eq(f.id)
+      expect(audit.version).to eq('v1')
+
+    end
+  end
+end

data/spec/models/curation_concerns/collection_behavior_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'rspec/active_model/mocks'
+
+describe CurationConcerns::CollectionBehavior do
+  # All behavior for Collection are defined in CC::CollectionBehavior, so we use
+  # a Collection instance to test.
+  let(:collection) { FactoryGirl.build(:collection) }
+  subject { collection }
+
+  it "should not allow a collection to be saved without a title" do
+     subject.title = nil
+     expect{ subject.save! }.to raise_error(ActiveFedora::RecordInvalid)
+  end
+
+  describe "::bytes" do
+    subject { collection.bytes }
+
+    context "with no items" do
+      before { collection.save }
+      it { is_expected.to eq 0 }
+    end
+
+    context "with two 50 byte files" do
+      let(:bitstream) { double("content", size: "50")}
+      let(:file) { mock_model ::GenericFile, content: bitstream }
+      before { allow(collection).to receive(:members).and_return([file, file]) }
+      it { is_expected.to eq 100 }
+    end
+  end
+
+  context '.add_member' do
+    let(:collectible?) { nil }
+    let(:proposed_collectible) { double(collections: []) }
+    before(:each) {
+      allow(proposed_collectible).to receive(:can_be_member_of_collection?).with(subject).and_return(collectible?)
+      allow(proposed_collectible).to receive(:save).and_return(true)
+    }
+
+    context 'with itself' do
+      it 'does not add it to the collection\'s members' do
+        expect {
+          subject.add_member(subject)
+        }.to_not change{ subject.members.size }
+      end
+    end
+
+    context 'with a non-collectible object' do
+      let(:collectible?) { false }
+      it 'does not add it to the collection\'s members' do
+        expect {
+          subject.add_member(proposed_collectible)
+        }.to_not change{ subject.members.size }
+      end
+    end
+
+    context 'with a collectible object' do
+      let(:collectible?) { true }
+      before do
+        allow(collection).to receive(:members).and_return([])
+      end
+      it 'adds it to the collection\'s members' do
+        expect {
+          subject.add_member(proposed_collectible)
+        }.to change{ subject.members.size }.by(1)
+      end
+    end
+  end
+
+  context 'is a pcdm:Collection instance' do
+    let(:collection1) { FactoryGirl.build(:collection) }
+    let(:work1) { FactoryGirl.build(:work) }
+
+    it 'should be a pcdm:Collection' do
+      expect(subject.pcdm_collection?).to be true
+      expect(subject.type).to include RDFVocabularies::PCDMTerms.Collection
+    end
+    it 'should not be a pcdm:Object' do
+      expect(subject.pcdm_object?).to be false
+      expect(subject.type).to_not include RDFVocabularies::PCDMTerms.Object
+    end
+    it 'should have child objects' do
+      expect(subject.child_generic_works).to eq []
+      expect(subject.child_generic_work_ids).to eq []
+      expect(subject.child_generic_works << work1).to eq [work1]
+      expect(subject.child_generic_works).to eq [work1]
+      expect(subject.child_generic_work_ids).to eq [work1.id]
+    end
+    it 'should have child collections' do
+      expect(subject.child_collections).to eq []
+      expect(subject.child_collection_ids).to eq []
+      expect(subject.child_collections << collection1).to eq [collection1]
+      expect(subject.child_collections).to eq [collection1]
+      expect(subject.child_collection_ids).to eq [collection1.id]
+    end
+    it 'should have related objects' do
+      expect(subject.related_objects).to eq []
+      expect(subject.related_objects << work1).to eq [work1]
+      expect(subject.related_objects).to eq [work1]
+    end
+    it 'should have parent collections' do
+      expect(subject.parent_collections).to eq []
+      expect(collection1.child_collections << subject).to eq [subject]
+      collection1.save
+      expect(subject.parent_collections).to eq [collection1]
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,35 @@
+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