curation_concerns 0.1.0 → 0.2.0

data/spec/jobs/create_derivatives_job_spec.rb

@@ -4,20 +4,22 @@ describe CurationConcerns::CreateDerivativesJob do
   before do
     @ffmpeg_enabled = CurationConcerns.config.enable_ffmpeg
     CurationConcerns.config.enable_ffmpeg = true
-    allow(ActiveFedora::Base).to receive(:find).with('123').and_return(generic_file)
-    allow(generic_file).to receive(:original_file).and_return(double("orignal_file", :has_content? => true))
+    allow(ActiveFedora::Base).to receive(:find).with('123').and_return(file_set)
+    allow(file_set).to receive(:mime_type).and_return('audio/x-wav')
+    allow(file_set).to receive(:id).and_return('123')
   end
-  let(:generic_file) { GenericFile.new }
+
+  let(:file_set) { FileSet.new }
 
   after do
     CurationConcerns.config.enable_ffmpeg = @ffmpeg_enabled
   end
 
-  subject { CreateDerivativesJob.new('123') }
-
-  it "should call create_derivatives and save on a generic_file" do
-    expect(generic_file).to receive(:create_derivatives)
-    expect(generic_file).to receive(:save)
-    subject.run
+  context "with a file name" do
+    it 'calls create_derivatives and save on a file set' do
+      expect(Hydra::Derivatives::AudioDerivatives).to receive(:create)
+      expect(file_set).to receive(:update_index)
+      CreateDerivativesJob.perform_now('123', 'spec/fixtures/piano_note.wav')
+    end
   end
 end

data/spec/jobs/import_url_job_spec.rb

@@ -1,19 +1,20 @@
 require 'spec_helper'
 
 describe ImportUrlJob do
-  let(:user) { FactoryGirl.find_or_create(:jill) }
+  let(:user) { create(:user) }
 
-  let(:file_path) {  fixture_path + '/world.png' }
-  let(:file_hash)  {'/673467823498723948237462429793840923582'}
+  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
+  let(:file_set) do
+    FileSet.new(import_url: "http://example.org#{file_hash}", label: file_path) do |f|
       f.apply_depositor_metadata(user.user_key)
     end
   end
 
+  let(:file_set_id) { 'abc123' }
+  let(:actor) { double }
+
   let(:mock_response) do
     double('response').tap do |http_res|
       allow(http_res).to receive(:start).and_yield
@@ -22,24 +23,16 @@ describe ImportUrlJob do
     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
+  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)
+      allow(ActiveFedora::Base).to receive(:find).with(file_set_id).and_return(file_set)
+      allow(CurationConcerns::FileSetActor).to receive(:new).with(file_set, user).and_return(actor)
     end
 
-    it "should create a content datastream" do
+    it 'creates 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
+      expect(actor).to receive(:create_content).and_return(true)
+      described_class.perform_now(file_set_id)
     end
   end
 end

data/spec/jobs/ingest_file_job_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe IngestFileJob do
+  let(:file_set) { create(:file_set) }
+  let(:filename) { fixture_file_path('/world.png') }
+
+  it 'uses the provided mime_type' do
+    described_class.perform_now(file_set.id, filename, 'image/png', 'bob')
+    expect(file_set.reload.original_file.mime_type).to eq 'image/png'
+  end
+
+  context 'with two existing versions from different users' do
+    let(:file1)       { fixture_file_path 'world.png' }
+    let(:file2)       { fixture_file_path 'small_file.txt' }
+    let(:actor1)      { described_class.new(file_set, user) }
+    let(:actor2)      { described_class.new(file_set, second_user) }
+
+    let(:second_user) { create(:user) }
+    let(:versions) { file_set.reload.original_file.versions }
+
+    before do
+      described_class.perform_now(file_set.id, file1, 'image/png', 'bob')
+      described_class.perform_now(file_set.id, file2, 'text/plain', 'bess')
+    end
+
+    it 'has two versions' do
+      expect(versions.all.count).to eq 2
+
+      # the current version
+      expect(CurationConcerns::VersioningService.latest_version_of(file_set.reload.original_file).label).to eq 'version2'
+      expect(file_set.original_file.content).to eq File.open(file2).read
+      expect(file_set.original_file.mime_type).to eq 'text/plain'
+      expect(file_set.original_file.original_name).to eq 'small_file.txt'
+
+      # the user for each version
+      expect(VersionCommitter.where(version_id: versions.first.uri).pluck(:committer_login)).to eq ['bob']
+      expect(VersionCommitter.where(version_id: versions.last.uri).pluck(:committer_login)).to eq ['bess']
+    end
+  end
+
+  it 'runs the after_create_content callback with file_set and user arguments' do
+    expect(CurationConcerns.config.callback).to receive(:run).with(:after_create_content, file_set, 'bob').exactly(1).times
+    described_class.perform_now(file_set.id, filename, 'image/png', 'bob')
+  end
+end

data/spec/jobs/ingest_local_file_job_spec.rb

@@ -1,25 +1,23 @@
 require 'spec_helper'
 
 describe IngestLocalFileJob do
-  let(:user) { FactoryGirl.find_or_create(:jill) }
+  let(:user) { create(:user) }
+
+  let(:file_set) { FileSet.new }
+  let(:file_set_id) { 'abc123' }
+  let(:actor) { double }
 
-  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
+    Dir.mkdir mock_upload_directory unless File.exist? mock_upload_directory
     FileUtils.copy(File.expand_path('../../fixtures/world.png', __FILE__), mock_upload_directory)
+    allow(FileSet).to receive(:find).with(file_set_id).and_return(file_set)
+    allow(CurationConcerns::FileSetActor).to receive(:new).with(file_set, user).and_return(actor)
   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)
+
+  it 'has attached a file' do
+    expect(actor).to receive(:create_content).and_return(true)
+    described_class.perform_now(file_set_id, mock_upload_directory, 'world.png', user.user_key)
   end
 end

data/spec/jobs/upload_set_update_job_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe UploadSetUpdateJob do
+  let(:user) { create(:user) }
+  let(:upload_set) { UploadSet.create }
+
+  let!(:file)  { create(:file_set, user: user, upload_set: upload_set) }
+  let!(:file2) { create(:file_set, user: user, upload_set: upload_set) }
+
+  describe "#perform" do
+    let(:title) { { file.id => ['File One'], file2.id => ['File Two'] } }
+    let(:metadata) { { tag: [''] } }
+    let(:visibility) { nil }
+
+    subject { described_class.perform_now(user.user_key, upload_set.id, title, metadata, visibility) }
+
+    it "updates file metadata" do
+      expect(subject).to be true
+      expect(file.reload.title).to eq ['File One']
+    end
+
+    context "when user does not have permission to edit all of the files" do
+      before do
+        expect_any_instance_of(User).to receive(:can?).with(:edit, file).and_return(true)
+        expect_any_instance_of(User).to receive(:can?).with(:edit, file2).and_return(false)
+      end
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/jobs/visibility_copy_job_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe VisibilityCopyJob do
+  describe 'an open access work' do
+    let(:work) { create(:work_with_files) }
+
+    it 'copies visibility to its contained files' do
+      # files are private at the outset
+      expect(work.file_sets.first.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+
+      work.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      work.save
+      described_class.perform_now(work.id)
+      work.reload.file_sets.each do |file|
+        expect(file.visibility).to eq 'open'
+      end
+    end
+  end
+
+  describe 'an embargoed work' do
+    let(:work) { create(:embargoed_work_with_files) }
+
+    before do
+      expect(work.visibility).to eq 'restricted'
+      expect(work).to be_under_embargo
+      expect(work.file_sets.first).to_not be_under_embargo
+    end
+
+    before do
+      described_class.perform_now(work.id)
+      work.reload
+    end
+    let(:file) { work.file_sets.first }
+
+    it 'copies visibility to its contained files and apply a copy of the embargo to the files' do
+      expect(file).to be_under_embargo
+      expect(file.embargo.id).to_not eq work.embargo.id
+    end
+  end
+
+  describe 'an leased work' do
+    let(:work) { create(:leased_work_with_files) }
+
+    before do
+      expect(work.visibility).to eq 'open'
+      expect(work).to be_active_lease
+      expect(work.file_sets.first).to_not be_active_lease
+    end
+
+    before do
+      described_class.perform_now(work.id)
+      work.reload
+    end
+    let(:file) { work.file_sets.first }
+
+    it 'copies visibility to its contained files and apply a copy of the lease to the files' do
+      expect(file).to be_active_lease
+      expect(file.lease.id).to_not eq work.lease.id
+    end
+  end
+end

data/spec/lib/curation_concerns/callbacks/registry_spec.rb

@@ -0,0 +1,54 @@
+require 'curation_concerns/callbacks/registry'
+
+describe CurationConcerns::Callbacks::Registry do
+  subject { described_class.new }
+
+  describe "#enabled?" do
+    it "returns false if the specified callback has not been enabled" do
+      expect(subject.enabled?(:foo))
+    end
+
+    it "returns true after enabling the specified callback" do
+      subject.enable(:foo)
+      expect(subject.enabled?(:foo)).to eq true
+    end
+  end
+
+  describe "#set?" do
+    it "returns false if the callback has not been set" do
+      expect(subject.set?(:foo)).to eq false
+    end
+
+    it "returns true if the callback has been set" do
+      subject.set(:foo) { nil }
+      expect(subject.set?(:foo)).to eq true
+    end
+  end
+
+  describe "#set" do
+    it "raises an error if a block is not given" do
+      expect { subject.set(:foo) }.to raise_error CurationConcerns::Callbacks::NoBlockGiven
+    end
+
+    it "raises an error if given no arguments" do
+      expect { subject.set }.to raise_error ArgumentError
+    end
+  end
+
+  describe "#run" do
+    it "raises a NotEnabled error if the callback has not been enabled" do
+      expect { subject.run(:foo) }.to raise_error CurationConcerns::Callbacks::NotEnabled
+    end
+
+    it "runs the specified callback with parameters" do
+      subject.set(:foo) { |x, y| x + y }
+      expect(subject.run(:foo, 1, 2)).to eq 3
+    end
+
+    it "runs the most recently set callback" do
+      subject.set(:foo) { "first" }
+      subject.set(:foo) { "second" }
+      expect(subject.run(:foo)).to eq "second"
+    end
+  end
+end

data/spec/lib/curation_concerns/callbacks_spec.rb

@@ -0,0 +1,27 @@
+require 'curation_concerns/callbacks'
+
+describe CurationConcerns::Callbacks do
+  context 'when included in a class,' do
+    before do
+      class TestClass
+        include CurationConcerns::Callbacks
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :TestClass)
+    end
+
+    describe '.callback' do
+      it 'returns an instance of Callbacks::Registry' do
+        expect(TestClass.callback).to be_a CurationConcerns::Callbacks::Registry
+      end
+    end
+
+    describe '#callback' do
+      it 'is an instance method shortcut to the class method of the same name' do
+        expect(TestClass.new.callback).to eq TestClass.callback
+      end
+    end
+  end
+end

data/spec/lib/curation_concerns/messages_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe CurationConcerns::Messages do
-
   let(:message) do
     TestClass.new
   end
@@ -16,54 +15,54 @@ describe CurationConcerns::Messages 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>" }
+  let(:upload_set_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/file_sets/1'>File 1</a>, <a href='/concern/file_sets/2'>File 2</a>, <a href='/concern/file_sets/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")
+  describe 'message subjects' do
+    it 'provides 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")
+    it 'provides 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\"]")
+  describe '#single_success' do
+    it 'renders a success message for a single file' do
+      node = Capybara::Node::Simple.new(message.single_success(upload_set_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/file_sets/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.")
+  describe '#multiple_success' do
+    it 'renders a success message for multiple files' do
+      node = Capybara::Node::Simple.new(message.multiple_success(upload_set_id, multiple))
+      expect(node).to have_selector("span[id=\"ss-1\"]", text: 'These files have been saved.')
       expect(node).to have_selector("a[data-content=\"#{file_list}\"][rel=\"popover\"][data-title=\"Files uploaded successfully\"]")
     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\"]")
+  describe '#single_failure' do
+    it 'renders a failure message for a single file' do
+      node = Capybara::Node::Simple.new(message.single_failure(upload_set_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/file_sets/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.")
+  describe '#multiple_failure' do
+    it 'renders a failure message for multiple files' do
+      node = Capybara::Node::Simple.new(message.multiple_failure(upload_set_id, multiple))
+      expect(node).to have_selector("span[id=\"ss-1\"]", text: 'These files could not be updated. You do not have sufficient privileges to edit them.')
       expect(node).to have_selector("a[data-content=\"#{file_list}\"][rel=\"popover\"][data-title=\"Files failed\"]")
     end
   end
 
-  describe "#file_list" do
-    it "should replace double-quotes with single quotes" do
+  describe '#file_list' do
+    it 'replaces double-quotes with single quotes' do
       expect(message.file_list(multiple)).to eq(file_list)
     end
   end

data/spec/lib/curation_concerns/readable_permissions_spec.rb

@@ -1,56 +1,54 @@
 require 'spec_helper'
 
 describe CurationConcerns::Permissions::Readable do
-
   class SubjectClass
     include CurationConcerns::Permissions::Readable
-    attr_accessor :read_groups 
+    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"]
+  describe '#public?' do
+    it 'returns true for public items' do
+      subject.read_groups = %w(public othergroup)
       expect(subject).to be_public
     end
-    it "should return fale for non-public items" do
-      subject.read_groups = ["notpublic","othergroup"]
+    it 'returns fale for non-public items' do
+      subject.read_groups = %w(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"]
+  describe '#registered?' do
+    it 'returns true for registered items' do
+      subject.read_groups = %w(registered othergroup)
       expect(subject).to be_registered
     end
-    it "should return fale for non-registered items" do
-      subject.read_groups = ["othergroup"]
+    it 'returns 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
+  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"]
+        subject.read_groups = ['othergroup']
         expect(subject).to be_private
       end
     end
-    context "is false" do
+    context 'is false' do
       specify "when 'registered' group is present" do
-        subject.read_groups = ["registered"]
+        subject.read_groups = ['registered']
         expect(subject).to_not be_private
       end
       specify "when 'public' group is present" do
-        subject.read_groups = ["public"]
+        subject.read_groups = ['public']
         expect(subject).to_not be_private
       end
     end
   end
-
 end

data/spec/lib/curation_concerns/writable_permissions_spec.rb

@@ -1,16 +1,14 @@
 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
+  describe '#permissions' do
+    it 'initializes with nothing specified' do
       expect(subject.permissions).to be_empty
     end
   end
-
 end

data/spec/matchers/metadata_field_matchers.rb

@@ -4,7 +4,7 @@ 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)
+    field_value.nil? || !field_value.is_a?(Array)
   end
 
   description do

data/spec/matchers/response_matchers.rb

@@ -1,7 +1,7 @@
-RSpec::Matchers.define :fail_redirect_and_flash do |path,flash_message|
+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
+end

data/spec/matchers.rb

@@ -3,11 +3,12 @@ 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]
+      $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]
+      $SHOW_MATCHERS[matcher_name] = caller.first.split(':')[0..1]
       super
     end
   end