sufia 4.0.1 → 4.1.0

data/spec/helpers/trophy_helper_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe TrophyHelper do
+describe TrophyHelper, :type => :helper do
   describe "#display_trophy_link" do
     let(:user) { FactoryGirl.create(:user) }
     let(:noid) { '9999' }

data/spec/jobs/audit_job_spec.rb

@@ -13,19 +13,19 @@ describe AuditJob do
   end
   describe "passing audit" do
     it "should not send passing mail" do
-      ActiveFedora::RelsExtDatastream.any_instance.stub(:dsChecksumValid).and_return(true)
+      allow_any_instance_of(ActiveFedora::RelsExtDatastream).to receive(:dsChecksumValid).and_return(true)
       AuditJob.new(@file.pid, "RELS-EXT", @file.rels_ext.versionID).run
       @inbox = @user.mailbox.inbox
-      @inbox.count.should == 0
+      expect(@inbox.count).to eq(0)
     end
   end
   describe "failing audit" do
     it "should send failing mail" do
-      ActiveFedora::RelsExtDatastream.any_instance.stub(:dsChecksumValid).and_return(false)
+      allow_any_instance_of(ActiveFedora::RelsExtDatastream).to receive(:dsChecksumValid).and_return(false)
       AuditJob.new(@file.pid, "RELS-EXT", @file.rels_ext.versionID).run
       @inbox = @user.mailbox.inbox
-      @inbox.count.should == 1
-      @inbox.each { |msg| msg.last_message.subject.should == AuditJob::FAIL }
+      expect(@inbox.count).to eq(1)
+      @inbox.each { |msg| expect(msg.last_message.subject).to eq(AuditJob::FAIL) }
     end
   end
 end

data/spec/jobs/batch_update_job_spec.rb

@@ -34,28 +34,28 @@ describe BatchUpdateJob do
     end
     context "with a failing update" do
       it "should check permissions for each file before updating" do
-        User.any_instance.should_receive(:can?).with(:edit, @file).and_return(false)
-        User.any_instance.should_receive(:can?).with(:edit, @file2).and_return(false)
+        expect_any_instance_of(User).to receive(:can?).with(:edit, @file).and_return(false)
+        expect_any_instance_of(User).to receive(:can?).with(:edit, @file2).and_return(false)
         BatchUpdateJob.new(@user.user_key, params).run
-        @user.mailbox.inbox[0].messages[0].subject.should == "Batch upload permission denied"
-        @user.mailbox.inbox[0].messages[0].body.should include("data-content")
-        @user.mailbox.inbox[0].messages[0].body.should include("These files")
+        expect(@user.mailbox.inbox[0].messages[0].subject).to eq("Batch upload permission denied")
+        expect(@user.mailbox.inbox[0].messages[0].body).to include("data-content")
+        expect(@user.mailbox.inbox[0].messages[0].body).to include("These files")
       end
     end
     context "with a passing update" do
       let(:s1) { double('one') }
       let(:s2) { double('two') }
       it "should log a content update event" do
-        User.any_instance.should_receive(:can?).with(:edit, @file).and_return(true)
-        User.any_instance.should_receive(:can?).with(:edit, @file2).and_return(true)
-        ContentUpdateEventJob.should_receive(:new).with(@file.pid, @user.user_key).and_return(s1)
-        Sufia.queue.should_receive(:push).with(s1).once
-        ContentUpdateEventJob.should_receive(:new).with(@file2.pid, @user.user_key).and_return(s2)
-        Sufia.queue.should_receive(:push).with(s2).once
+        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(true)
+        expect(ContentUpdateEventJob).to receive(:new).with(@file.pid, @user.user_key).and_return(s1)
+        expect(Sufia.queue).to receive(:push).with(s1).once
+        expect(ContentUpdateEventJob).to receive(:new).with(@file2.pid, @user.user_key).and_return(s2)
+        expect(Sufia.queue).to receive(:push).with(s2).once
         BatchUpdateJob.new(@user.user_key, params).run
-        @user.mailbox.inbox[0].messages[0].subject.should == "Batch upload complete"
-        @user.mailbox.inbox[0].messages[0].body.should include("data-content")
-        @user.mailbox.inbox[0].messages[0].body.should include("These files")
+        expect(@user.mailbox.inbox[0].messages[0].subject).to eq("Batch upload complete")
+        expect(@user.mailbox.inbox[0].messages[0].body).to include("data-content")
+        expect(@user.mailbox.inbox[0].messages[0].body).to include("These files")
       end
     end
   end

data/spec/jobs/content_depositor_change_event_job_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe ContentDepositorChangeEventJob do
+  before do
+    @depositor = FactoryGirl.find_or_create(:jill)
+    @receiver = FactoryGirl.find_or_create(:archivist)
+    @file = ::GenericFile.new.tap do |gf|
+      gf.apply_depositor_metadata(@depositor.user_key)
+      gf.save!
+    end
+    ContentDepositorChangeEventJob.new(@file.pid, @receiver.user_key).run
+  end
+  after do
+    @file.destroy
+  end
+  it "changes the depositor and records an original depositor" do
+    @file.reload
+    expect(@file.depositor).to eq @receiver.user_key
+    expect(@file.proxy_depositor).to eq @depositor.user_key
+    expect(@file.edit_users).to include(@receiver.user_key, @depositor.user_key)
+  end
+end

data/spec/jobs/event_jobs_spec.rb

@@ -24,168 +24,168 @@ describe 'event jobs' do
     @another_user.follow(@user)
     count_user = @user.events.length
     count_another = @another_user.events.length
-    Time.should_receive(:now).at_least(:once).and_return(1)
+    expect(Time).to receive(:now).at_least(:once).and_return(1)
     event = { action: 'User <a href="/users/jilluser@example-dot-com">jilluser@example.com</a> has edited his or her profile', timestamp: '1' }
     UserEditProfileEventJob.new(@user.user_key).run
-    @user.events.length.should == count_user + 1
-    @user.events.first.should == event
-    @another_user.events.length.should == count_another + 1
-    @another_user.events.first.should == event
+    expect(@user.events.length).to eq(count_user + 1)
+    expect(@user.events.first).to eq(event)
+    expect(@another_user.events.length).to eq(count_another + 1)
+    expect(@another_user.events.first).to eq(event)
   end
   it "should log user follow events" do
     # UserFollow should log the event to the follower's dashboard, the followee's dashboard, and followers' dashboards
     @third_user.follow(@user)
-    @user.events.length.should == 0
-    @another_user.events.length.should == 0
-    @third_user.events.length.should == 0
-    Time.should_receive(:now).at_least(:once).and_return(1)
+    expect(@user.events.length).to eq(0)
+    expect(@another_user.events.length).to eq(0)
+    expect(@third_user.events.length).to eq(0)
+    expect(Time).to receive(:now).at_least(:once).and_return(1)
     event = { action: 'User <a href="/users/jilluser@example-dot-com">jilluser@example.com</a> is now following <a href="/users/archivist1@example-dot-com">archivist1@example.com</a>', timestamp: '1' }
     UserFollowEventJob.new(@user.user_key, @another_user.user_key).run
-    @user.events.length.should == 1
-    @user.events.first.should == event
-    @another_user.events.length.should == 1
-    @another_user.events.first.should == event
-    @third_user.events.length.should == 1
-    @third_user.events.first.should == event
+    expect(@user.events.length).to eq(1)
+    expect(@user.events.first).to eq(event)
+    expect(@another_user.events.length).to eq(1)
+    expect(@another_user.events.first).to eq(event)
+    expect(@third_user.events.length).to eq(1)
+    expect(@third_user.events.first).to eq(event)
   end
   it "should log user unfollow events" do
     # UserUnfollow should log the event to the unfollower's dashboard, the unfollowee's dashboard, and followers' dashboards
     @third_user.follow(@user)
     @user.follow(@another_user)
-    @user.events.length.should == 0
-    @another_user.events.length.should == 0
-    @third_user.events.length.should == 0
-    Time.should_receive(:now).at_least(:once).and_return(1)
+    expect(@user.events.length).to eq(0)
+    expect(@another_user.events.length).to eq(0)
+    expect(@third_user.events.length).to eq(0)
+    expect(Time).to receive(:now).at_least(:once).and_return(1)
     event = { action: 'User <a href="/users/jilluser@example-dot-com">jilluser@example.com</a> has unfollowed <a href="/users/archivist1@example-dot-com">archivist1@example.com</a>', timestamp: '1' }
     UserUnfollowEventJob.new(@user.user_key, @another_user.user_key).run
-    @user.events.length.should == 1
-    @user.events.first.should == event
-    @another_user.events.length.should == 1
-    @another_user.events.first.should == event
-    @third_user.events.length.should == 1
-    @third_user.events.first.should == event
+    expect(@user.events.length).to eq(1)
+    expect(@user.events.first).to eq(event)
+    expect(@another_user.events.length).to eq(1)
+    expect(@another_user.events.first).to eq(event)
+    expect(@third_user.events.length).to eq(1)
+    expect(@third_user.events.first).to eq(event)
   end
   it "should log content deposit events" do
     # ContentDeposit should log the event to the depositor's profile, followers' dashboards, and the GF
     @another_user.follow(@user)
     @third_user.follow(@user)
-    User.any_instance.stub(:can?).and_return(true)
-    @user.profile_events.length.should == 0
-    @another_user.events.length.should == 0
-    @third_user.events.length.should == 0
-    @gf.events.length.should == 0
-    Time.should_receive(:now).at_least(:once).and_return(1)
+    allow_any_instance_of(User).to receive(:can?).and_return(true)
+    expect(@user.profile_events.length).to eq(0)
+    expect(@another_user.events.length).to eq(0)
+    expect(@third_user.events.length).to eq(0)
+    expect(@gf.events.length).to eq(0)
+    expect(Time).to receive(:now).at_least(:once).and_return(1)
     event = {action: 'User <a href="/users/jilluser@example-dot-com">jilluser@example.com</a> has deposited <a href="/files/123">Hamlet</a>', timestamp: '1' }
     ContentDepositEventJob.new('test:123', @user.user_key).run
-    @user.profile_events.length.should == 1
-    @user.profile_events.first.should == event
-    @another_user.events.length.should == 1
-    @another_user.events.first.should == event
-    @third_user.events.length.should == 1
-    @third_user.events.first.should == event
-    @gf.events.length.should == 1
-    @gf.events.first.should == event
+    expect(@user.profile_events.length).to eq(1)
+    expect(@user.profile_events.first).to eq(event)
+    expect(@another_user.events.length).to eq(1)
+    expect(@another_user.events.first).to eq(event)
+    expect(@third_user.events.length).to eq(1)
+    expect(@third_user.events.first).to eq(event)
+    expect(@gf.events.length).to eq(1)
+    expect(@gf.events.first).to eq(event)
   end
   it "should log content update events" do
     # ContentUpdate should log the event to the depositor's profile, followers' dashboards, and the GF
     @another_user.follow(@user)
     @third_user.follow(@user)
-    User.any_instance.stub(:can?).and_return(true)
-    @user.profile_events.length.should == 0
-    @another_user.events.length.should == 0
-    @third_user.events.length.should == 0
-    @gf.events.length.should == 0
-    Time.should_receive(:now).at_least(:once).and_return(1)
+    allow_any_instance_of(User).to receive(:can?).and_return(true)
+    expect(@user.profile_events.length).to eq(0)
+    expect(@another_user.events.length).to eq(0)
+    expect(@third_user.events.length).to eq(0)
+    expect(@gf.events.length).to eq(0)
+    expect(Time).to receive(:now).at_least(:once).and_return(1)
     event = {action: 'User <a href="/users/jilluser@example-dot-com">jilluser@example.com</a> has updated <a href="/files/123">Hamlet</a>', timestamp: '1' }
     ContentUpdateEventJob.new('test:123', @user.user_key).run
-    @user.profile_events.length.should == 1
-    @user.profile_events.first.should == event
-    @another_user.events.length.should == 1
-    @another_user.events.first.should == event
-    @third_user.events.length.should == 1
-    @third_user.events.first.should == event
-    @gf.events.length.should == 1
-    @gf.events.first.should == event
+    expect(@user.profile_events.length).to eq(1)
+    expect(@user.profile_events.first).to eq(event)
+    expect(@another_user.events.length).to eq(1)
+    expect(@another_user.events.first).to eq(event)
+    expect(@third_user.events.length).to eq(1)
+    expect(@third_user.events.first).to eq(event)
+    expect(@gf.events.length).to eq(1)
+    expect(@gf.events.first).to eq(event)
   end
   it "should log content new version events" do
     # ContentNewVersion should log the event to the depositor's profile, followers' dashboards, and the GF
     @another_user.follow(@user)
     @third_user.follow(@user)
-    User.any_instance.stub(:can?).and_return(true)
-    @user.profile_events.length.should == 0
-    @another_user.events.length.should == 0
-    @third_user.events.length.should == 0
-    @gf.events.length.should == 0
-    Time.should_receive(:now).at_least(:once).and_return(1)
+    allow_any_instance_of(User).to receive(:can?).and_return(true)
+    expect(@user.profile_events.length).to eq(0)
+    expect(@another_user.events.length).to eq(0)
+    expect(@third_user.events.length).to eq(0)
+    expect(@gf.events.length).to eq(0)
+    expect(Time).to receive(:now).at_least(:once).and_return(1)
     event = {action: 'User <a href="/users/jilluser@example-dot-com">jilluser@example.com</a> has added a new version of <a href="/files/123">Hamlet</a>', timestamp: '1' }
     ContentNewVersionEventJob.new('test:123', @user.user_key).run
-    @user.profile_events.length.should == 1
-    @user.profile_events.first.should == event
-    @another_user.events.length.should == 1
-    @another_user.events.first.should == event
-    @third_user.events.length.should == 1
-    @third_user.events.first.should == event
-    @gf.events.length.should == 1
-    @gf.events.first.should == event
+    expect(@user.profile_events.length).to eq(1)
+    expect(@user.profile_events.first).to eq(event)
+    expect(@another_user.events.length).to eq(1)
+    expect(@another_user.events.first).to eq(event)
+    expect(@third_user.events.length).to eq(1)
+    expect(@third_user.events.first).to eq(event)
+    expect(@gf.events.length).to eq(1)
+    expect(@gf.events.first).to eq(event)
   end
   it "should log content restored version events" do
     # ContentRestoredVersion should log the event to the depositor's profile, followers' dashboards, and the GF
     @another_user.follow(@user)
     @third_user.follow(@user)
-    User.any_instance.stub(:can?).and_return(true)
-    @user.profile_events.length.should == 0
-    @another_user.events.length.should == 0
-    @third_user.events.length.should == 0
-    @gf.events.length.should == 0
-    Time.should_receive(:now).at_least(:once).and_return(1)
+    allow_any_instance_of(User).to receive(:can?).and_return(true)
+    expect(@user.profile_events.length).to eq(0)
+    expect(@another_user.events.length).to eq(0)
+    expect(@third_user.events.length).to eq(0)
+    expect(@gf.events.length).to eq(0)
+    expect(Time).to receive(:now).at_least(:once).and_return(1)
     event = {action: 'User <a href="/users/jilluser@example-dot-com">jilluser@example.com</a> has restored a version \'content.0\' of <a href="/files/123">Hamlet</a>', timestamp: '1' }
     ContentRestoredVersionEventJob.new('test:123', @user.user_key, 'content.0').run
-    @user.profile_events.length.should == 1
-    @user.profile_events.first.should == event
-    @another_user.events.length.should == 1
-    @another_user.events.first.should == event
-    @third_user.events.length.should == 1
-    @third_user.events.first.should == event
-    @gf.events.length.should == 1
-    @gf.events.first.should == event
+    expect(@user.profile_events.length).to eq(1)
+    expect(@user.profile_events.first).to eq(event)
+    expect(@another_user.events.length).to eq(1)
+    expect(@another_user.events.first).to eq(event)
+    expect(@third_user.events.length).to eq(1)
+    expect(@third_user.events.first).to eq(event)
+    expect(@gf.events.length).to eq(1)
+    expect(@gf.events.first).to eq(event)
   end
   it "should log content delete events" do
     # ContentDelete should log the event to the depositor's profile and followers' dashboards
     @another_user.follow(@user)
     @third_user.follow(@user)
-    @user.profile_events.length.should == 0
-    @another_user.events.length.should == 0
-    @third_user.events.length.should == 0
-    Time.should_receive(:now).at_least(:once).and_return(1)
+    expect(@user.profile_events.length).to eq(0)
+    expect(@another_user.events.length).to eq(0)
+    expect(@third_user.events.length).to eq(0)
+    expect(Time).to receive(:now).at_least(:once).and_return(1)
     event = {action: 'User <a href="/users/jilluser@example-dot-com">jilluser@example.com</a> has deleted file \'123\'', timestamp: '1' }
     ContentDeleteEventJob.new('test:123', @user.user_key).run
-    @user.profile_events.length.should == 1
-    @user.profile_events.first.should == event
-    @another_user.events.length.should == 1
-    @another_user.events.first.should == event
-    @third_user.events.length.should == 1
-    @third_user.events.first.should == event
+    expect(@user.profile_events.length).to eq(1)
+    expect(@user.profile_events.first).to eq(event)
+    expect(@another_user.events.length).to eq(1)
+    expect(@another_user.events.first).to eq(event)
+    expect(@third_user.events.length).to eq(1)
+    expect(@third_user.events.first).to eq(event)
   end
   it "should not log content-related jobs to followers who lack access" do
     # No Content-related eventjobs should log an event to a follower who does not have access to the GF
     @another_user.follow(@user)
     @third_user.follow(@user)
-    @user.profile_events.length.should == 0
-    @another_user.events.length.should == 0
-    @third_user.events.length.should == 0
-    @gf.events.length.should == 0
+    expect(@user.profile_events.length).to eq(0)
+    expect(@another_user.events.length).to eq(0)
+    expect(@third_user.events.length).to eq(0)
+    expect(@gf.events.length).to eq(0)
     @now = Time.now
-    Time.should_receive(:now).at_least(:once).and_return(@now)
+    expect(Time).to receive(:now).at_least(:once).and_return(@now)
     event = {action: 'User <a href="/users/jilluser@example-dot-com">jilluser@example.com</a> has updated <a href="/files/123">Hamlet</a>', timestamp: @now.to_i.to_s }
     ContentUpdateEventJob.new('test:123', @user.user_key).run
-    @user.profile_events.length.should == 1
-    @user.profile_events.first.should == event
-    @another_user.events.length.should == 0
-    @another_user.events.first.should be_nil
-    @third_user.events.length.should == 0
-    @third_user.events.first.should be_nil
-    @gf.events.length.should == 1
-    @gf.events.first.should == event
+    expect(@user.profile_events.length).to eq(1)
+    expect(@user.profile_events.first).to eq(event)
+    expect(@another_user.events.length).to eq(0)
+    expect(@another_user.events.first).to be_nil
+    expect(@third_user.events.length).to eq(0)
+    expect(@third_user.events.first).to be_nil
+    expect(@gf.events.length).to eq(1)
+    expect(@gf.events.first).to eq(event)
   end
 end
 

data/spec/jobs/import_url_job_spec.rb

@@ -29,7 +29,7 @@ describe ImportUrlJob do
   subject(:job) { ImportUrlJob.new(generic_file.id) }
 
   it "should have no content at the outset" do
-    generic_file.content.size.should be_nil
+    expect(generic_file.content.size).to be_nil
   end
 
   context "after running the job" do
@@ -46,7 +46,7 @@ describe ImportUrlJob do
     end
 
     it "should create a content datastream" do
-      Net::HTTP.any_instance.should_receive(:request_get).with(file_hash).and_yield(mock_response)
+      expect_any_instance_of(Net::HTTP).to receive(:request_get).with(file_hash).and_yield(mock_response)
       job.run
       expect(generic_file.reload.content.size).to eq 4218
       expect(generic_file.content.dsLabel).to eq file_path

data/spec/jobs/ingest_local_file_job_spec.rb

@@ -21,7 +21,7 @@ describe IngestLocalFileJob do
 
   it "should have attached a file" do
     job.run
-    generic_file.reload.content.size.should == 4218
+    expect(generic_file.reload.content.size).to eq(4218)
   end
 
   describe "virus checking" do

data/spec/lib/sufia/breadcrumbs_spec.rb

@@ -28,7 +28,7 @@ describe Sufia::Breadcrumbs do
   describe "#default_trail" do
     context "when the user is logged in" do
       before do
-        crumbs.stub(:user_signed_in?) { true }
+        allow(crumbs).to receive(:user_signed_in?) { true }
       end
       specify "the default trail is nil" do
         expect(crumbs.default_trail).to eql([[I18n.t('sufia.dashboard.title'), sufia.dashboard_index_path]])
@@ -36,7 +36,7 @@ describe Sufia::Breadcrumbs do
     end
     context "when there is no user" do
       before do
-        crumbs.stub(:user_signed_in?) { false }
+        allow(crumbs).to receive(:user_signed_in?) { false }
       end
       specify "the default trail is nil" do
         expect(crumbs.default_trail).to be_nil
@@ -57,7 +57,7 @@ describe Sufia::Breadcrumbs do
     context "when coming from the dashboard" do
       before do
         allow(crumbs.request).to receive(:referer).and_return("http://...dashboard/")
-        crumbs.stub(:user_signed_in?) { true }
+        allow(crumbs).to receive(:user_signed_in?) { true }
       end
       specify "the trail goes back to the user's files" do
         allow(crumbs).to receive(:controller_name).and_return("my/files")

data/spec/lib/sufia/id_service_spec.rb

@@ -4,7 +4,7 @@ describe Sufia::IdService do
   describe "mint" do
     subject { Sufia::IdService.mint }
 
-    it { should_not be_empty }
+    it { is_expected.not_to be_empty }
 
     it "should not mint the same id twice in a row" do
       expect(Sufia::IdService.mint).to_not eq subject

data/spec/lib/sufia/upload_complete_behavior_spec.rb

@@ -19,18 +19,18 @@ describe Sufia::FilesController::UploadCompleteBehavior do
   let (:test_id) {"123abc"}
   context "Not overridden" do
     it "respond with the batch edit path" do
-      UploadThing.upload_complete_path(test_id).should == Sufia::Engine.routes.url_helpers.batch_edit_path(test_id)
+      expect(UploadThing.upload_complete_path(test_id)).to eq(Sufia::Engine.routes.url_helpers.batch_edit_path(test_id))
     end
     it "respond with the dashboard path" do
-      UploadThing.destroy_complete_path({}).should ==   Sufia::Engine.routes.url_helpers.dashboard_files_path
+      expect(UploadThing.destroy_complete_path({})).to eq(Sufia::Engine.routes.url_helpers.dashboard_files_path)
     end
   end
   context "overriden path" do
     it "respond with the batch edit path" do
-      UploadThingRedefine.upload_complete_path(test_id).should == "example.com"
+      expect(UploadThingRedefine.upload_complete_path(test_id)).to eq("example.com")
     end
     it "respond with the batch edit path" do
-      UploadThingRedefine.destroy_complete_path(test_id).should == "destroy.com"
+      expect(UploadThingRedefine.destroy_complete_path(test_id)).to eq("destroy.com")
     end
   end
 end