sufia 4.0.1 → 4.1.0

data/spec/models/generic_file_rdf_datastream_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe GenericFileRdfDatastream do
+describe GenericFileRdfDatastream, :type => :model do
   it "should have bibliographicCitation" do
     subject.bibliographic_citation = "foo"
     expect(subject.bibliographic_citation).to eq ["foo"]

data/spec/models/generic_file_spec.rb

@@ -1,6 +1,40 @@
 require 'spec_helper'
 
-describe GenericFile do
+describe GenericFile, :type => :model do
+  let(:user) { FactoryGirl.find_or_create(:jill) }
+
+  before(:each) do
+    @file = GenericFile.new
+    @file.apply_depositor_metadata(user.user_key)
+  end
+
+  describe "created for someone (proxy)" do
+    before do
+      @transfer_to = FactoryGirl.find_or_create(:jill)
+    end
+    after do
+      @file.destroy
+    end
+
+    it "transfers the request" do
+      @file.on_behalf_of = @transfer_to.user_key
+      stub_job = double('change depositor job')
+      allow(ContentDepositorChangeEventJob).to receive(:new).and_return(stub_job)
+      expect(Sufia.queue).to receive(:push).with(stub_job).once.and_return(true)
+      @file.save!
+    end
+  end
+
+  describe "delegations" do
+    before do
+      @file.proxy_depositor = "sally@example.com"
+    end
+    it "should include proxies" do
+      expect(@file).to respond_to(:relative_path)
+      expect(@file).to respond_to(:depositor)
+      expect(@file.proxy_depositor).to eq 'sally@example.com'
+    end
+  end
 
   subject { GenericFile.new }
 
@@ -56,176 +90,176 @@ describe GenericFile do
     context "when pdf?" do
       it "should be true for pdf" do
         subject.mime_type = 'application/pdf'
-        subject.should be_pdf
+        expect(subject).to be_pdf
       end
     end
     context "when audio?" do
       it "should be true for wav" do
         subject.mime_type = 'audio/x-wave'
-        subject.should be_audio
+        expect(subject).to be_audio
         subject.mime_type = 'audio/x-wav'
-        subject.should be_audio
+        expect(subject).to be_audio
       end
       it "should be true for mpeg" do
         subject.mime_type = 'audio/mpeg'
-        subject.should be_audio
+        expect(subject).to be_audio
         subject.mime_type = 'audio/mp3'
-        subject.should be_audio
+        expect(subject).to be_audio
       end
       it "should be true for ogg" do
         subject.mime_type = 'audio/ogg'
-        subject.should be_audio
+        expect(subject).to be_audio
       end
     end
     context "when video?" do
       it "should be true for avi" do
         subject.mime_type = 'video/avi'
-        subject.should be_video
+        expect(subject).to be_video
       end
       it "should be true for webm" do
         subject.mime_type = 'video/webm'
-        subject.should be_video
+        expect(subject).to be_video
       end
       it "should be true for mpeg" do
         subject.mime_type = 'video/mp4'
-        subject.should be_video
+        expect(subject).to be_video
         subject.mime_type = 'video/mpeg'
-        subject.should be_video
+        expect(subject).to be_video
       end
       it "should be true for quicktime" do
         subject.mime_type = 'video/quicktime'
-        subject.should be_video
+        expect(subject).to be_video
       end
       it "should be true for mxf" do
         subject.mime_type = 'application/mxf'
-        subject.should be_video
+        expect(subject).to be_video
       end
     end
   end
 
   describe "visibility" do
     it "should not be changed when it's new" do
-      subject.should_not be_visibility_changed
+      expect(subject).not_to be_visibility_changed
     end
     it "should be changed when it has been changed" do
       subject.visibility= 'open'
-      subject.should be_visibility_changed
+      expect(subject).to be_visibility_changed
     end
 
     it "should not be changed when it's set to its previous value" do
       subject.visibility= 'restricted'
-      subject.should_not be_visibility_changed
+      expect(subject).not_to be_visibility_changed
     end
 
   end
 
   describe "attributes" do
     it "should have rightsMetadata" do
-      subject.rightsMetadata.should be_instance_of ParanoidRightsDatastream
+      expect(subject.rightsMetadata).to be_instance_of ParanoidRightsDatastream
     end
     it "should have properties datastream for depositor" do
-      subject.properties.should be_instance_of PropertiesDatastream
+      expect(subject.properties).to be_instance_of PropertiesDatastream
     end
     it "should have apply_depositor_metadata" do
-      subject.rightsMetadata.edit_access.should == ['jcoyne']
-      subject.depositor.should == 'jcoyne'
+      expect(subject.rightsMetadata.edit_access).to eq(['jcoyne'])
+      expect(subject.depositor).to eq('jcoyne')
     end
     it "should have a set of permissions" do
       subject.read_groups=['group1', 'group2']
       subject.edit_users=['user1']
       subject.read_users=['user2', 'user3']
-      subject.permissions.should == [{type: "group", access: "read", name: "group1"},
+      expect(subject.permissions).to eq([{type: "group", access: "read", name: "group1"},
           {type: "group", access: "read", name: "group2"},
           {type: "user", access: "read", name: "user2"},
           {type: "user", access: "read", name: "user3"},
-          {type: "user", access: "edit", name: "user1"}]
+          {type: "user", access: "edit", name: "user1"}])
     end
     describe "updating permissions" do
       it "should create new group permissions" do
         subject.permissions = {new_group_name: {'group1'=>'read'}}
-        subject.permissions.should == [{type: "group", access: "read", name: "group1"},
-                                     {type: "user", access: "edit", name: "jcoyne"}]
+        expect(subject.permissions).to eq([{type: "group", access: "read", name: "group1"},
+                                     {type: "user", access: "edit", name: "jcoyne"}])
       end
       it "should create new user permissions" do
         subject.permissions = {new_user_name: {'user1'=>'read'}}
-        subject.permissions.should == [{type: "user", access: "read", name: "user1"},
-                                     {type: "user", access: "edit", name: "jcoyne"}]
+        expect(subject.permissions).to eq([{type: "user", access: "read", name: "user1"},
+                                     {type: "user", access: "edit", name: "jcoyne"}])
       end
       it "should not replace existing groups" do
         subject.permissions = {new_group_name: {'group1' => 'read'}}
         subject.permissions = {new_group_name: {'group2' => 'read'}}
-        subject.permissions.should == [{type: "group", access: "read", name: "group1"},
+        expect(subject.permissions).to eq([{type: "group", access: "read", name: "group1"},
                                      {type: "group", access: "read", name: "group2"},
-                                     {type: "user", access: "edit", name: "jcoyne"}]
+                                     {type: "user", access: "edit", name: "jcoyne"}])
       end
       it "should not replace existing users" do
         subject.permissions = {new_user_name:{'user1'=>'read'}}
         subject.permissions = {new_user_name:{'user2'=>'read'}}
-        subject.permissions.should == [{type: "user", access: "read", name: "user1"},
+        expect(subject.permissions).to eq([{type: "user", access: "read", name: "user1"},
                                      {type: "user", access: "read", name: "user2"},
-                                     {type: "user", access: "edit", name: "jcoyne"}]
+                                     {type: "user", access: "edit", name: "jcoyne"}])
       end
       it "should update permissions on existing users" do
         subject.permissions = {new_user_name:{'user1'=>'read'}}
         subject.permissions = {user:{'user1'=>'edit'}}
-        subject.permissions.should == [{type: "user", access: "edit", name: "user1"},
-                                     {type: "user", access: "edit", name: "jcoyne"}]
+        expect(subject.permissions).to eq([{type: "user", access: "edit", name: "user1"},
+                                     {type: "user", access: "edit", name: "jcoyne"}])
       end
       it "should update permissions on existing groups" do
         subject.permissions = {new_group_name:{'group1'=>'read'}}
         subject.permissions = {group:{'group1'=>'edit'}}
-        subject.permissions.should == [{type: "group", access: "edit", name: "group1"},
-                                     {type: "user", access: "edit", name: "jcoyne"}]
+        expect(subject.permissions).to eq([{type: "group", access: "edit", name: "group1"},
+                                     {type: "user", access: "edit", name: "jcoyne"}])
       end
     end
     it "should have a characterization datastream" do
-      subject.characterization.should be_kind_of FitsDatastream
+      expect(subject.characterization).to be_kind_of FitsDatastream
     end
     it "should have a dc desc metadata" do
-      subject.descMetadata.should be_kind_of GenericFileRdfDatastream
+      expect(subject.descMetadata).to be_kind_of GenericFileRdfDatastream
     end
     it "should have content datastream" do
       subject.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
-      subject.content.should be_kind_of FileContentDatastream
+      expect(subject.content).to be_kind_of FileContentDatastream
     end
   end
   describe "delegations" do
     it "should delegate methods to properties metadata" do
-      subject.should respond_to(:relative_path)
-      subject.should respond_to(:depositor)
+      expect(subject).to respond_to(:relative_path)
+      expect(subject).to respond_to(:depositor)
     end
     it "should delegate methods to descriptive metadata" do
-      subject.should respond_to(:related_url)
-      subject.should respond_to(:based_near)
-      subject.should respond_to(:part_of)
-      subject.should respond_to(:contributor)
-      subject.should respond_to(:creator)
-      subject.should respond_to(:title)
-      subject.should respond_to(:description)
-      subject.should respond_to(:publisher)
-      subject.should respond_to(:date_created)
-      subject.should respond_to(:date_uploaded)
-      subject.should respond_to(:date_modified)
-      subject.should respond_to(:subject)
-      subject.should respond_to(:language)
-      subject.should respond_to(:rights)
-      subject.should respond_to(:resource_type)
-      subject.should respond_to(:identifier)
+      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
-      subject.should respond_to(:format_label)
-      subject.should respond_to(:mime_type)
-      subject.should respond_to(:file_size)
-      subject.should respond_to(:last_modified)
-      subject.should respond_to(:filename)
-      subject.should respond_to(:original_checksum)
-      subject.should respond_to(:well_formed)
-      subject.should respond_to(:file_title)
-      subject.should respond_to(:file_author)
-      subject.should respond_to(:page_count)
+      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
-      subject.to_param.should == subject.noid
+      expect(subject.to_param).to eq(subject.noid)
     end
     describe "that have been saved" do
       # This file has no content, so it doesn't characterize
@@ -244,10 +278,10 @@ describe GenericFile do
       it "should have activity stream-related methods defined" do
         subject.save
         f = subject.reload
-        f.should respond_to(:stream)
-        f.should respond_to(:events)
-        f.should respond_to(:create_event)
-        f.should respond_to(:log_event)
+        expect(f).to respond_to(:stream)
+        expect(f).to respond_to(:events)
+        expect(f).to respond_to(:create_event)
+        expect(f).to respond_to(:log_event)
       end
       it "should be able to set values via delegated methods" do
         subject.related_url = ["http://example.org/"]
@@ -255,23 +289,23 @@ describe GenericFile do
         subject.title = ["New work"]
         subject.save
         f = subject.reload
-        f.related_url.should == ["http://example.org/"]
-        f.creator.should == ["John Doe"]
-        f.title.should == ["New work"]
+        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
-        f.creator.should == ["John Doe"]
-        f.title.should == ["New work"]
+        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
-        f.creator.should == ["Jane Doe"]
-        f.title.should == ["New work", "Newer work"]
+        expect(f.creator).to eq(["Jane Doe"])
+        expect(f.title).to eq(["New work", "Newer work"])
       end
     end
   end
@@ -327,12 +361,12 @@ describe GenericFile do
   end
   it "should support multi-valued fields in solr" do
     subject.tag = ["tag1", "tag2"]
-    lambda { subject.save }.should_not raise_error
+    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"
-    subject.relative_path.should == "documents/research/NSF/2010"
+    expect(subject.relative_path).to eq("documents/research/NSF/2010")
   end
   describe "create_thumbnail" do
     before do
@@ -344,14 +378,14 @@ describe GenericFile do
     end
     describe "with a video", if: Sufia.config.enable_ffmpeg do
       before do
-        @f.stub(mime_type: 'video/quicktime')  #Would get set by the characterization job
+        allow(@f).to receive_messages(mime_type: 'video/quicktime')  #Would get set by the characterization job
         @f.add_file(File.open("#{fixture_path}/countdown.avi", 'rb'), 'content', 'countdown.avi')
         @f.save
       end
       it "should make a png thumbnail" do
         @f.create_thumbnail
-        @f.thumbnail.content.size.should == 4768 # this is a bad test. I just want to show that it did something.
-        @f.thumbnail.mimeType.should == 'image/png'
+        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.mimeType).to eq('image/png')
       end
     end
   end
@@ -384,33 +418,33 @@ describe GenericFile do
     end
     it "should schedule a audit job for each datastream" do
       s0 = double('zero')
-      AuditJob.should_receive(:new).with(@f.pid, 'descMetadata', "descMetadata.0").and_return(s0)
-      Sufia.queue.should_receive(:push).with(s0)
+      expect(AuditJob).to receive(:new).with(@f.pid, 'descMetadata', "descMetadata.0").and_return(s0)
+      expect(Sufia.queue).to receive(:push).with(s0)
       s1 = double('one')
-      AuditJob.should_receive(:new).with(@f.pid, 'DC', "DC1.0").and_return(s1)
-      Sufia.queue.should_receive(:push).with(s1)
+      expect(AuditJob).to receive(:new).with(@f.pid, 'DC', "DC1.0").and_return(s1)
+      expect(Sufia.queue).to receive(:push).with(s1)
       s2 = double('two')
-      AuditJob.should_receive(:new).with(@f.pid, 'RELS-EXT', "RELS-EXT.0").and_return(s2)
-      Sufia.queue.should_receive(:push).with(s2)
+      expect(AuditJob).to receive(:new).with(@f.pid, 'RELS-EXT', "RELS-EXT.0").and_return(s2)
+      expect(Sufia.queue).to receive(:push).with(s2)
       s3 = double('three')
-      AuditJob.should_receive(:new).with(@f.pid, 'rightsMetadata', "rightsMetadata.0").and_return(s3)
-      Sufia.queue.should_receive(:push).with(s3)
+      expect(AuditJob).to receive(:new).with(@f.pid, 'rightsMetadata', "rightsMetadata.0").and_return(s3)
+      expect(Sufia.queue).to receive(:push).with(s3)
       s4 = double('four')
-      AuditJob.should_receive(:new).with(@f.pid, 'properties', "properties.0").and_return(s4)
-      Sufia.queue.should_receive(:push).with(s4)
+      expect(AuditJob).to receive(:new).with(@f.pid, 'properties', "properties.0").and_return(s4)
+      expect(Sufia.queue).to receive(:push).with(s4)
       s5 = double('five')
-      AuditJob.should_receive(:new).with(@f.pid, 'content', "content.0").and_return(s5)
-      Sufia.queue.should_receive(:push).with(s5)
+      expect(AuditJob).to receive(:new).with(@f.pid, 'content', "content.0").and_return(s5)
+      expect(Sufia.queue).to receive(:push).with(s5)
       @f.audit!
     end
     it "should log a failing audit" do
-      @f.datastreams.each { |ds| ds.stub(:dsChecksumValid).and_return(false) }
-      GenericFile.stub(:run_audit).and_return(double(:respose, pass:1, created_at: '2005-12-20', pid: 'foo:123', dsid: 'foo', version: '1'))
+      @f.datastreams.each { |ds| allow(ds).to receive(:dsChecksumValid).and_return(false) }
+      allow(GenericFile).to receive(:run_audit).and_return(double(:respose, pass:1, created_at: '2005-12-20', pid: 'foo:123', dsid: 'foo', version: '1'))
       @f.audit!
       expect(ChecksumAuditLog.all).to be_all { |cal| cal.pass == 0 }
     end
     it "should log a passing audit" do
-      GenericFile.stub(:run_audit).and_return(double(:respose, pass:1, created_at: '2005-12-20', pid: 'foo:123', dsid: 'foo', version: '1'))
+      allow(GenericFile).to receive(:run_audit).and_return(double(:respose, pass:1, created_at: '2005-12-20', pid: 'foo:123', dsid: 'foo', version: '1'))
       @f.audit!
       expect(ChecksumAuditLog.all).to be_all { |cal| cal.pass == 1 }
     end
@@ -431,22 +465,22 @@ describe GenericFile do
       @new = ChecksumAuditLog.create(pid: @f.pid, dsid: @version.dsid, version: @version.versionID, pass: 0)
     end
     it "should not prune failed audits" do
-      @version.should_receive(:dsChecksumValid).and_return(true)
+      expect(@version).to receive(:dsChecksumValid).and_return(true)
       GenericFile.run_audit(@version)
 
-      @version.should_receive(:dsChecksumValid).and_return(false)
+      expect(@version).to receive(:dsChecksumValid).and_return(false)
       GenericFile.run_audit(@version)
 
-      @version.should_receive(:dsChecksumValid).and_return(false)
+      expect(@version).to receive(:dsChecksumValid).and_return(false)
       GenericFile.run_audit(@version)
 
-      @version.should_receive(:dsChecksumValid).and_return(true)
+      expect(@version).to receive(:dsChecksumValid).and_return(true)
       GenericFile.run_audit(@version)
 
-      @version.should_receive(:dsChecksumValid).and_return(false)
+      expect(@version).to receive(:dsChecksumValid).and_return(false)
       GenericFile.run_audit(@version)
 
-      @f.logs(@version.dsid).map(&:pass).should == [0, 1, 0, 0, 1, 0, 1]
+      expect(@f.logs(@version.dsid).map(&:pass)).to eq([0, 1, 0, 0, 1, 0, 1])
     end
 
   end
@@ -503,15 +537,15 @@ describe GenericFile do
       @new_file.delete
     end
     it "should support the noid method" do
-      @new_file.should respond_to(:noid)
+      expect(@new_file).to respond_to(:noid)
     end
     it "should return the expected identifier" do
-      @new_file.noid.should == '123'
+      expect(@new_file.noid).to eq('123')
     end
     it "should work outside of an instance" do
       new_id = Sufia::IdService.mint
       noid = new_id.split(':').last
-      Sufia::Noid.noidify(new_id).should == noid
+      expect(Sufia::Noid.noidify(new_id)).to eq(noid)
     end
   end
   describe "characterize" do
@@ -519,7 +553,7 @@ describe GenericFile do
       subject.add_file(File.open(fixture_path + '/world.png'), 'content', 'world.png')
       subject.characterize
       doc = Nokogiri::XML.parse(subject.characterization.content)
-      doc.root.xpath('//ns:imageWidth/text()', {'ns'=>'http://hul.harvard.edu/ois/xml/ns/fits/fits_output'}).inner_text.should == '50'
+      expect(doc.root.xpath('//ns:imageWidth/text()', {'ns'=>'http://hul.harvard.edu/ois/xml/ns/fits/fits_output'}).inner_text).to eq('50')
     end
     context "after characterization" do
       before(:all) do
@@ -535,25 +569,25 @@ describe GenericFile do
         @myfile.destroy
       end
       it "should return expected results after a save" do
-        @myfile.file_size.should == ['218882']
-        @myfile.original_checksum.should == ['5a2d761cab7c15b2b3bb3465ce64586d']
+        expect(@myfile.file_size).to eq(['218882'])
+        expect(@myfile.original_checksum).to eq(['5a2d761cab7c15b2b3bb3465ce64586d'])
       end
       it "should return a hash of all populated values from the characterization terminology" do
-        @myfile.characterization_terms[:format_label].should == ["Portable Document Format"]
-        @myfile.characterization_terms[:mime_type].should == "application/pdf"
-        @myfile.characterization_terms[:file_size].should == ["218882"]
-        @myfile.characterization_terms[:original_checksum].should == ["5a2d761cab7c15b2b3bb3465ce64586d"]
-        @myfile.characterization_terms.keys.should include(:last_modified)
-        @myfile.characterization_terms.keys.should include(:filename)
+        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)
+        expect(@myfile.characterization_terms.keys).to include(:filename)
       end
       it "should append metadata from the characterization" do
-        @myfile.title.should include("Microsoft Word - sample.pdf.docx")
-        @myfile.filename[0].should == @myfile.label
+        expect(@myfile.title).to include("Microsoft Word - sample.pdf.docx")
+        expect(@myfile.filename[0]).to eq(@myfile.label)
       end
       it "should append each term only once" do
         @myfile.append_metadata
-        @myfile.format_label.should == ["Portable Document Format"]
-        @myfile.title.should include("Microsoft Word - sample.pdf.docx")
+        expect(@myfile.format_label).to eq(["Portable Document Format"])
+        expect(@myfile.title).to include("Microsoft Word - sample.pdf.docx")
       end
       it 'includes extracted full-text content' do
         expect(@myfile.full_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")
@@ -563,7 +597,7 @@ describe GenericFile do
   describe "label" do
     it "should set the inner label" do
       subject.label = "My New Label"
-      subject.inner_object.label.should == "My New Label"
+      expect(subject.inner_object.label).to eq("My New Label")
     end
   end
   context "with rightsMetadata" do
@@ -574,27 +608,27 @@ describe GenericFile do
       m
     end
     it "should have read groups accessor" do
-      subject.read_groups.should == ['group-6', 'group-7']
+      expect(subject.read_groups).to eq(['group-6', 'group-7'])
     end
     it "should have read groups string accessor" do
-      subject.read_groups_string.should == 'group-6, group-7'
+      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']
-      subject.rightsMetadata.groups.should == {'group-2' => 'read', 'group-3'=>'read', 'group-8' => 'edit'}
-      subject.rightsMetadata.users.should == {"person1"=>"read","person2"=>"read", 'jcoyne' => 'edit'}
+      expect(subject.rightsMetadata.groups).to eq({'group-2' => 'read', 'group-3'=>'read', 'group-8' => 'edit'})
+      expect(subject.rightsMetadata.users).to eq({"person1"=>"read","person2"=>"read", 'jcoyne' => 'edit'})
     end
 
     it "should have read groups string writer" do
       subject.read_groups_string = 'umg/up.dlt.staff, group-3'
-      subject.rightsMetadata.groups.should == {'umg/up.dlt.staff' => 'read', 'group-3'=>'read', 'group-8' => 'edit'}
-      subject.rightsMetadata.users.should == {"person1"=>"read","person2"=>"read", 'jcoyne' => 'edit'}
+      expect(subject.rightsMetadata.groups).to eq({'umg/up.dlt.staff' => 'read', 'group-3'=>'read', 'group-8' => 'edit'})
+      expect(subject.rightsMetadata.users).to eq({"person1"=>"read","person2"=>"read", 'jcoyne' => 'edit'})
     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
-      subject.rightsMetadata.groups.should == {'group-2' => 'read', 'group-3'=>'read', 'group-7' => 'read', 'group-8' => 'edit'}
-      subject.rightsMetadata.users.should == {"person1"=>"read","person2"=>"read", 'jcoyne' => 'edit'}
+      expect(subject.rightsMetadata.groups).to eq({'group-2' => 'read', 'group-3'=>'read', 'group-7' => 'read', 'group-8' => 'edit'})
+      expect(subject.rightsMetadata.users).to eq({"person1"=>"read","person2"=>"read", 'jcoyne' => 'edit'})
     end
   end
   describe "permissions validation" do
@@ -634,66 +668,66 @@ describe GenericFile do
       end
       it "should work via permissions=()" do
         @file.permissions = {user: {'mjg36' => 'read'}}
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_users)
-        @file.errors[:edit_users].should include('Depositor must have edit access')
+        expect(@file.errors).to include(:edit_users)
+        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_attributes" do
         # automatically triggers save
-        lambda { @file.update_attributes(read_users_string: 'mjg36') }.should_not raise_error
+        expect { @file.update_attributes(read_users_string: 'mjg36') }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_users)
-        @file.errors[:edit_users].should include('Depositor must have edit access')
+        expect(@file.errors).to include(:edit_users)
+        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_indexed_attributes" do
         @rightsmd.update_indexed_attributes([:edit_access, :person] => '')
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_users)
-        @file.errors[:edit_users].should include('Depositor must have edit access')
+        expect(@file.errors).to include(:edit_users)
+        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via permissions()" do
         @rightsmd.permissions({person: "mjg36"}, "read")
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_users)
-        @file.errors[:edit_users].should include('Depositor must have edit access')
+        expect(@file.errors).to include(:edit_users)
+        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_permissions()" do
         @rightsmd.update_permissions({"person" => {"mjg36" => "read"}})
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_users)
-        @file.errors[:edit_users].should include('Depositor must have edit access')
+        expect(@file.errors).to include(:edit_users)
+        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via content=()" do
         @rightsmd.content=(@rights_xml)
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_users)
-        @file.errors[:edit_users].should include('Depositor must have edit access')
+        expect(@file.errors).to include(:edit_users)
+        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via ng_xml=()" do
         @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_users)
-        @file.errors[:edit_users].should include('Depositor must have edit access')
+        expect(@file.errors).to include(:edit_users)
+        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_values()" do
         @rightsmd.update_values([:edit_access, :person] => '')
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_users)
-        @file.errors[:edit_users].should include('Depositor must have edit access')
+        expect(@file.errors).to include(:edit_users)
+        expect(@file.errors[:edit_users]).to include('Depositor must have edit access')
         expect(@file).to_not be_valid
       end
     end
@@ -734,66 +768,66 @@ describe GenericFile do
       end
       it "should work via permissions=()" do
         @file.permissions = {group: {'public' => 'edit'}}
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Public cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_attributes" do
         # automatically triggers save
-        lambda { @file.update_attributes(edit_groups_string: 'public') }.should_not raise_error
+        expect { @file.update_attributes(edit_groups_string: 'public') }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Public cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_indexed_attributes" do
         @rightsmd.update_indexed_attributes([:edit_access, :group] => 'public')
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Public cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via permissions()" do
         @rightsmd.permissions({group: "public"}, "edit")
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Public cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_permissions()" do
         @rightsmd.update_permissions({"group" => {"public" => "edit"}})
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Public cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via content=()" do
         @rightsmd.content=(@rights_xml)
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Public cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via ng_xml=()" do
         @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Public cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_values()" do
         @rightsmd.update_values([:edit_access, :group] => 'public')
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Public cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Public cannot have edit access')
         expect(@file).to_not be_valid
       end
     end
@@ -834,66 +868,66 @@ describe GenericFile do
       end
       it "should work via permissions=()" do
         @file.permissions = {group: {'registered' => 'edit'}}
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Registered cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_attributes" do
         # automatically triggers save
-        lambda { @file.update_attributes(edit_groups_string: 'registered') }.should_not raise_error
+        expect { @file.update_attributes(edit_groups_string: 'registered') }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Registered cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_indexed_attributes" do
         @rightsmd.update_indexed_attributes([:edit_access, :group] => 'registered')
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Registered cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via permissions()" do
         @rightsmd.permissions({group: "registered"}, "edit")
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Registered cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_permissions()" do
         @rightsmd.update_permissions({"group" => {"registered" => "edit"}})
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Registered cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via content=()" do
         @rightsmd.content=(@rights_xml)
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Registered cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via ng_xml=()" do
         @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Registered cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
         expect(@file).to_not be_valid
       end
       it "should work via update_values()" do
         @rightsmd.update_values([:edit_access, :group] => 'registered')
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to be_new_record
-        @file.errors.should include(:edit_groups)
-        @file.errors[:edit_groups].should include('Registered cannot have edit access')
+        expect(@file.errors).to include(:edit_groups)
+        expect(@file.errors[:edit_groups]).to include('Registered cannot have edit access')
         expect(@file).to_not be_valid
       end
     end
@@ -936,58 +970,58 @@ describe GenericFile do
       end
       it "should work via permissions=()" do
         @file.permissions = {group: {'registered' => 'read'}}
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to_not be_new_record
-        @file.errors.should be_empty
+        expect(@file.errors).to be_empty
         expect(@file).to be_valid
       end
       it "should work via update_attributes" do
         # automatically triggers save
-        lambda { @file.update_attributes(read_groups_string: 'registered') }.should_not raise_error
+        expect { @file.update_attributes(read_groups_string: 'registered') }.not_to raise_error
         expect(@file).to_not be_new_record
-        @file.errors.should be_empty
+        expect(@file.errors).to be_empty
         expect(@file).to be_valid
       end
       it "should work via update_indexed_attributes" do
         @rightsmd.update_indexed_attributes([:read_access, :group] => 'registered')
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to_not be_new_record
-        @file.errors.should be_empty
+        expect(@file.errors).to be_empty
         expect(@file).to be_valid
       end
       it "should work via permissions()" do
         @rightsmd.permissions({group: "registered"}, "read")
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to_not be_new_record
-        @file.errors.should be_empty
+        expect(@file.errors).to be_empty
         expect(@file).to be_valid
       end
       it "should work via update_permissions()" do
         @rightsmd.update_permissions({"group" => {"registered" => "read"}})
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to_not be_new_record
-        @file.errors.should be_empty
+        expect(@file.errors).to be_empty
         expect(@file).to be_valid
       end
       it "should work via content=()" do
         @rightsmd.content=(@rights_xml)
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to_not be_new_record
-        @file.errors.should be_empty
+        expect(@file.errors).to be_empty
         expect(@file).to be_valid
       end
       it "should work via ng_xml=()" do
         @rightsmd.ng_xml=(Nokogiri::XML::Document.parse(@rights_xml))
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to_not be_new_record
-        @file.errors.should be_empty
+        expect(@file.errors).to be_empty
         expect(@file).to be_valid
       end
       it "should work via update_values()" do
         @rightsmd.update_values([:read_access, :group] => 'registered')
-        lambda { @file.save }.should_not raise_error
+        expect { @file.save }.not_to raise_error
         expect(@file).to_not be_new_record
-        @file.errors.should be_empty
+        expect(@file.errors).to be_empty
         expect(@file).to be_valid
       end
     end
@@ -1002,7 +1036,7 @@ describe GenericFile do
         allow(Sufia::GenericFile::Actor).to receive(:virus_check).and_raise(Sufia::VirusFoundError, "A virus was found in #{f.path}: EL CRAPO VIRUS")
         subject.add_file(f, 'content', 'small_file.txt')
         subject.save
-        subject.should_not be_persisted
+        expect(subject).not_to be_persisted
         expect(subject.errors.messages).to eq(base: ["A virus was found in #{f.path}: EL CRAPO VIRUS"])
       end
       it "does not save a new version of a GenericFile" do
@@ -1011,7 +1045,7 @@ describe GenericFile do
         allow(Sufia::GenericFile::Actor).to receive(:virus_check).and_raise(Sufia::VirusFoundError)
         subject.add_file(File.new(fixture_path + '/sufia_generic_stub.txt') , 'content', 'sufia_generic_stub.txt')
         subject.save
-        subject.reload.content.content.should == "small\n"
+        expect(subject.reload.content.content).to eq("small\n")
       end
     end
   end
@@ -1043,12 +1077,12 @@ describe GenericFile do
   describe "public?" do
     context "when read group is set to public" do
       before { subject.read_groups = ['public'] }
-      it { should be_public }
+      it { is_expected.to be_public }
     end
 
     context "when read group is not set to public" do
       before { subject.read_groups = ['foo'] }
-      it { should_not be_public }
+      it { is_expected.not_to be_public }
     end
   end
 end