active-fedora 6.7.8 → 6.8.0

data/spec/unit/base_delegate_to_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 describe ActiveFedora::Base do
 
-  describe "deletgating multiple terms to one datastream" do
+  describe 'deletgating multiple terms to one datastream' do
     class BarnyardDocument < ActiveFedora::OmDatastream
       set_terminology do |t|
-        t.root(:path=>"animals", :xmlns=>"urn:zoobar")
+        t.root(:path => 'animals', :xmlns => 'urn:zoobar')
         t.waterfowl do
           t.ducks do
             t.duck
@@ -16,60 +16,58 @@ describe ActiveFedora::Base do
         t.horse()
         t.chicken()
         t.pig()
-        t.duck(:ref=>[:waterfowl,:ducks,:duck])
+        t.duck(:ref => [:waterfowl, :ducks, :duck])
       end
 
       def self.xml_template
-            Nokogiri::XML::Document.parse '<animals xmlns="urn:zoobar">
-              <waterfowl>
-                <ducks>
-                  <duck/>
-                </ducks>
-              </waterfowl>
-              <donkey></donkey>
-              <cow></cow>
-              <horse></horse>
-              <chicken></chicken>
-              <pig></pig>
-            </animals>'
+        Nokogiri::XML::Document.parse '<animals xmlns="urn:zoobar">
+          <waterfowl>
+            <ducks>
+              <duck/>
+            </ducks>
+          </waterfowl>
+          <donkey></donkey>
+          <cow></cow>
+          <horse></horse>
+          <chicken></chicken>
+          <pig></pig>
+        </animals>'
       end
     end
 
     class Barnyard < ActiveFedora::Base
-      has_metadata :type=>BarnyardDocument, :name=>"xmlish"
+      has_metadata :type => BarnyardDocument, :name => 'xmlish'
       delegate_to :xmlish, [:cow, :chicken, :pig, :duck], multiple: true
-      delegate_to :xmlish, [:donkey, :horse], :unique=>true
-      #delegate :donkey, :to=>'xmlish', :unique=>true
+      delegate_to :xmlish, [:donkey, :horse], :unique => true
+      # delegate :donkey, :to=>'xmlish', :unique=>true
     end
     before :each do
       @n = Barnyard.new()
     end
-    it "should save a delegated property uniquely" do
-      @n.donkey="Bray"
-      @n.donkey.should == "Bray"
-      @n.xmlish.term_values(:donkey).first.should == 'Bray'
-      @n.horse="Winee"
-      @n.horse.should == "Winee"
-      @n.xmlish.term_values(:horse).first.should == 'Winee'
+    it 'should save a delegated property uniquely' do
+      @n.donkey = 'Bray'
+      expect(@n.donkey).to eq('Bray')
+      expect(@n.xmlish.term_values(:donkey).first).to eq('Bray')
+      @n.horse = 'Winee'
+      expect(@n.horse).to eq('Winee')
+      expect(@n.xmlish.term_values(:horse).first).to eq('Winee')
     end
-    it "should return an array if not marked as unique" do
-      ### Metadata datastream does not appear to support multiple value setting
-      @n.cow=["one", "two"]
-      @n.cow.should == ["one", "two"]
+    it 'should return an array if not marked as unique' do
+      # Metadata datastream does not appear to support multiple value setting
+      @n.cow = ['one', 'two']
+      expect(@n.cow).to eq(['one', 'two'])
     end
 
-    it "should be able to delegate deeply into the terminology" do
-      @n.duck=["Quack", "Peep"]
-      @n.duck.should == ["Quack", "Peep"]
+    it 'should be able to delegate deeply into the terminology' do
+      @n.duck = ['Quack', 'Peep']
+      expect(@n.duck).to eq(['Quack', 'Peep'])
     end
 
-    it "should be able to track change status" do
-      @n.chicken_changed?.should be_false
-      @n.chicken = ["Cheep"]
-      @n.chicken_changed?.should be_true
-    end 
+    it 'should be able to track change status' do
+      expect(@n.chicken_changed?).to be_falsey
+      @n.chicken = ['Cheep']
+      expect(@n.chicken_changed?).to be_truthy
+    end
 
   end
 end
-
-

data/spec/unit/base_extra_spec.rb

@@ -1,81 +1,81 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  
+
   before(:each) do
     @test_object = ActiveFedora::Base.new
   end
 
-  describe ".update_index" do
+  describe '.update_index' do
     before do
-      mock_conn = double("SolrConnection")
-      mock_conn.should_receive(:add)
-      mock_conn.should_receive(:commit)
-      mock_ss = double("SolrService")
-      mock_ss.stub(:conn).and_return(mock_conn)
-      ActiveFedora::SolrService.stub(:instance).and_return(mock_ss)
+      mock_conn = double('SolrConnection')
+      expect(mock_conn).to receive(:add)
+      expect(mock_conn).to receive(:commit)
+      mock_ss = double('SolrService')
+      allow(mock_ss).to receive(:conn).and_return(mock_conn)
+      allow(ActiveFedora::SolrService).to receive(:instance).and_return(mock_ss)
     end
-    
-    it "should call .to_solr on all SimpleDatastreams AND RelsExtDatastreams and pass the resulting document to solr" do
+
+    it 'should call .to_solr on all SimpleDatastreams AND RelsExtDatastreams and pass the resulting document to solr' do
       # Actually uses self.to_solr internally to gather solr info from all metadata datastreams
-      mock1 = double("ds1", :to_solr => {})
-      mock2 = double("ds2", :to_solr => {})
-      mock3 = double("RELS-EXT", :to_solr => {})
-      
+      mock1 = double('ds1', :to_solr => {})
+      mock2 = double('ds2', :to_solr => {})
+      mock3 = double('RELS-EXT', :to_solr => {})
+
       mock_datastreams = {:ds1 => mock1, :ds2 => mock2, :rels_ext => mock3}
-      mock1.should_receive(:solrize_profile).and_return({})
-      mock2.should_receive(:solrize_profile).and_return({})
-      mock3.should_receive(:solrize_profile).and_return({})
-      @test_object.should_receive(:datastreams).twice.and_return(mock_datastreams)
-      @test_object.should_receive(:solrize_relationships)
+      expect(mock1).to receive(:solrize_profile).and_return({})
+      expect(mock2).to receive(:solrize_profile).and_return({})
+      expect(mock3).to receive(:solrize_profile).and_return({})
+      expect(@test_object).to receive(:datastreams).twice.and_return(mock_datastreams)
+      expect(@test_object).to receive(:solrize_relationships)
       @test_object.update_index
     end
 
-    it "should call .to_solr on all RDFDatastreams and pass the resulting document to solr" do
+    it 'should call .to_solr on all RDFDatastreams and pass the resulting document to solr' do
       # Actually uses self.to_solr internally to gather solr info from all metadata datastreams
-      mock1 = double("ds1", :to_solr => {})
-      mock2 = double("ds2", :to_solr => {})
-      mock3 = double("RELS-EXT", :to_solr => {})
-      
+      mock1 = double('ds1', :to_solr => {})
+      mock2 = double('ds2', :to_solr => {})
+      mock3 = double('RELS-EXT', :to_solr => {})
+
       mock_datastreams = {:ds1 => mock1, :ds2 => mock2, :rels_ext => mock3}
-      mock1.should_receive(:solrize_profile).and_return({})
-      mock2.should_receive(:solrize_profile).and_return({})
-      mock3.should_receive(:solrize_profile).and_return({})
-      @test_object.should_receive(:datastreams).twice.and_return(mock_datastreams)
-      @test_object.should_receive(:solrize_relationships)
+      expect(mock1).to receive(:solrize_profile).and_return({})
+      expect(mock2).to receive(:solrize_profile).and_return({})
+      expect(mock3).to receive(:solrize_profile).and_return({})
+      expect(@test_object).to receive(:datastreams).twice.and_return(mock_datastreams)
+      expect(@test_object).to receive(:solrize_relationships)
       @test_object.update_index
     end
 
-    it "should retrieve a solr Connection and call Connection.add" do
+    it 'should retrieve a solr Connection and call Connection.add' do
       @test_object.update_index
     end
 
   end
-  
-  describe ".delete" do
-    
+
+  describe '.delete' do
+
     before(:each) do
     end
-    
-    it "should delete object from repository and index" do
-      @test_object.inner_object.stub(:delete)
-      mock_conn = double("SolrConnection")
-      mock_conn.should_receive(:delete_by_id).with(nil) 
-      mock_conn.should_receive(:commit)
-      mock_ss = double("SolrService")
-      mock_ss.stub(:conn).and_return(mock_conn)
-      ActiveFedora::SolrService.stub(:instance).and_return(mock_ss)
+
+    it 'should delete object from repository and index' do
+      allow(@test_object.inner_object).to receive(:delete)
+      mock_conn = double('SolrConnection')
+      expect(mock_conn).to receive(:delete_by_id).with(nil)
+      expect(mock_conn).to receive(:commit)
+      mock_ss = double('SolrService')
+      allow(mock_ss).to receive(:conn).and_return(mock_conn)
+      allow(ActiveFedora::SolrService).to receive(:instance).and_return(mock_ss)
       @test_object.delete
     end
 
   end
-  
-  describe '#pids_from_uris' do 
-    it "should strip the info:fedora/ out of a given string" do 
-      ActiveFedora::Base.pids_from_uris("info:fedora/FOOBAR").should == "FOOBAR"
+
+  describe '#pids_from_uris' do
+    it 'should strip the info:fedora/ out of a given string' do
+      expect(ActiveFedora::Base.pids_from_uris('info:fedora/FOOBAR')).to eq('FOOBAR')
     end
-    it "should accept an array of strings"do 
-      ActiveFedora::Base.pids_from_uris(["info:fedora/FOOBAR", "info:fedora/BAZFOO"]).should == ["FOOBAR", "BAZFOO"]
+    it 'should accept an array of strings'do
+      expect(ActiveFedora::Base.pids_from_uris(['info:fedora/FOOBAR', 'info:fedora/BAZFOO'])).to eq(['FOOBAR', 'BAZFOO'])
     end
   end
 

data/spec/unit/base_spec.rb

@@ -1,81 +1,81 @@
 require 'spec_helper'
-@@last_pid = 0  
+@@last_pid = 0
 
 describe ActiveFedora::Base do
-  it_behaves_like "An ActiveModel"
+  it_behaves_like 'An ActiveModel'
 
   describe 'descendants' do
-    it "should record the decendants" do
-      ActiveFedora::Base.descendants.should include(ModsArticle, SpecialThing)
+    it 'should record the decendants' do
+      expect(ActiveFedora::Base.descendants).to include(ModsArticle, SpecialThing)
     end
   end
 
-  describe "sharding" do
-    it "should have a shard_index" do
-      ActiveFedora::Base.shard_index(@this_pid).should == 0
+  describe 'sharding' do
+    it 'should have a shard_index' do
+      expect(ActiveFedora::Base.shard_index(@this_pid)).to eq(0)
     end
 
-    context "When the repository is NOT sharded" do
+    context 'When the repository is NOT sharded' do
       subject {ActiveFedora::Base.connection_for_pid('test:bar')}
       before(:each) do
-        ActiveFedora.config.stub(:sharded?).and_return(false)
+        allow(ActiveFedora.config).to receive(:sharded?).and_return(false)
         ActiveFedora::Base.fedora_connection = {}
-        ActiveFedora.config.stub(:credentials).and_return(:url=>'myfedora')
+        allow(ActiveFedora.config).to receive(:credentials).and_return(:url => 'myfedora')
       end
-      it { should be_kind_of Rubydora::Repository}
-      it "should be the standard connection" do
-        subject.client.url.should == 'myfedora'
+      it { is_expected.to be_kind_of Rubydora::Repository}
+      it 'should be the standard connection' do
+        expect(subject.client.url).to eq('myfedora')
       end
-      describe "assign_pid" do
-        it "should use fedora to generate pids" do
+      describe 'assign_pid' do
+        it 'should use fedora to generate pids' do
           # TODO: This juggling of Fedora credentials & establishing connections should be handled by an establish_fedora_connection method,
           # possibly wrap it all into a fedora_connection method - MZ 06-05-2012
-          stubfedora = double("Fedora")
-          stubfedora.should_receive(:connection).and_return(double("Connection", :mint =>"sample:newpid"))
+          stubfedora = double('Fedora')
+          expect(stubfedora).to receive(:connection).and_return(double('Connection', :mint => 'sample:newpid'))
           # Should use ActiveFedora.config.credentials as a single hash rather than an array of shards
-          ActiveFedora::RubydoraConnection.should_receive(:new).with(ActiveFedora.config.credentials).and_return(stubfedora)
+          expect(ActiveFedora::RubydoraConnection).to receive(:new).with(ActiveFedora.config.credentials).and_return(stubfedora)
           ActiveFedora::Base.assign_pid(ActiveFedora::Base.new.inner_object)
         end
       end
-      describe "shard_index" do
-        it "should always return zero (the first and only connection)" do
-          ActiveFedora::Base.shard_index('test:bar').should == 0
+      describe 'shard_index' do
+        it 'should always return zero (the first and only connection)' do
+          expect(ActiveFedora::Base.shard_index('test:bar')).to eq(0)
         end
       end
     end
-    context "When the repository is sharded" do
+    context 'When the repository is sharded' do
       before :each do
-        ActiveFedora.config.stub(:sharded?).and_return(true)
+        allow(ActiveFedora.config).to receive(:sharded?).and_return(true)
         ActiveFedora::Base.fedora_connection = {}
-        ActiveFedora.config.stub(:credentials).and_return([{:url=>'shard1'}, {:url=>'shard2'} ])
-      end
-      describe "assign_pid" do
-        it "should always use the first shard to generate pids" do
-          stubhard1 = double("Shard")
-          stubhard2 = double("Shard")
-          stubhard1.should_receive(:connection).and_return(double("Connection", :mint =>"sample:newpid"))
-          stubhard2.should_receive(:connection).never
+        allow(ActiveFedora.config).to receive(:credentials).and_return([{:url => 'shard1'}, {:url => 'shard2'} ])
+      end
+      describe 'assign_pid' do
+        it 'should always use the first shard to generate pids' do
+          stubhard1 = double('Shard')
+          stubhard2 = double('Shard')
+          expect(stubhard1).to receive(:connection).and_return(double('Connection', :mint => 'sample:newpid'))
+          expect(stubhard2).to receive(:connection).never
           ActiveFedora::Base.fedora_connection = {0 => stubhard1, 1 => stubhard2}
           ActiveFedora::Base.assign_pid(ActiveFedora::Base.new.inner_object)
         end
       end
-      describe "shard_index" do
-        it "should use modulo of md5 of the pid to distribute objects across shards" do
-          ActiveFedora::Base.shard_index('test:bar').should == 0
-          ActiveFedora::Base.shard_index('test:nanana').should == 1
+      describe 'shard_index' do
+        it 'should use modulo of md5 of the pid to distribute objects across shards' do
+          expect(ActiveFedora::Base.shard_index('test:bar')).to eq(0)
+          expect(ActiveFedora::Base.shard_index('test:nanana')).to eq(1)
         end
       end
-      describe "the repository" do
-        describe "for test:bar" do
+      describe 'the repository' do
+        describe 'for test:bar' do
           subject {ActiveFedora::Base.connection_for_pid('test:bar')}
-          it "should be shard1" do
-            subject.client.url.should == 'shard1'
+          it 'should be shard1' do
+            expect(subject.client.url).to eq('shard1')
           end
         end
-        describe "for test:baz" do
+        describe 'for test:baz' do
           subject {ActiveFedora::Base.connection_for_pid('test:nanana')}
-          it "should be shard1" do
-            subject.client.url.should == 'shard2'
+          it 'should be shard1' do
+            expect(subject.client.url).to eq('shard2')
           end
         end
       end
@@ -83,53 +83,53 @@ describe ActiveFedora::Base do
 
   end
 
-  describe "reindex_everything" do
-    it "should call update_index on every object except for the fedora-system objects" do
-       Rubydora::Repository.any_instance.should_receive(:search).
-            and_yield(double(pid:'XXX')).and_yield(double(pid:'YYY')).and_yield(double(pid:'ZZZ')).
-            and_yield(double(pid:'fedora-system:ServiceDeployment-3.0')).
-            and_yield(double(pid:'fedora-system:ServiceDefinition-3.0')).
-            and_yield(double(pid:'fedora-system:FedoraObject-3.0'))
+  describe 'reindex_everything' do
+    it 'should call update_index on every object except for the fedora-system objects' do
+       expect_any_instance_of(Rubydora::Repository).to receive(:search).
+            and_yield(double(pid: 'XXX')).and_yield(double(pid: 'YYY')).and_yield(double(pid: 'ZZZ')).
+            and_yield(double(pid: 'fedora-system:ServiceDeployment-3.0')).
+            and_yield(double(pid: 'fedora-system:ServiceDefinition-3.0')).
+            and_yield(double(pid: 'fedora-system:FedoraObject-3.0'))
 
        mock_update = double(:mock_obj)
-       mock_update.should_receive(:update_index).exactly(3).times
-       ActiveFedora::Base.should_receive(:find).with('XXX', :cast=>true).and_return(mock_update)
-       ActiveFedora::Base.should_receive(:find).with('YYY', :cast=>true).and_return(mock_update)
-       ActiveFedora::Base.should_receive(:find).with('ZZZ', :cast=>true).and_return(mock_update)
+       expect(mock_update).to receive(:update_index).exactly(3).times
+       expect(ActiveFedora::Base).to receive(:find).with('XXX', :cast => true).and_return(mock_update)
+       expect(ActiveFedora::Base).to receive(:find).with('YYY', :cast => true).and_return(mock_update)
+       expect(ActiveFedora::Base).to receive(:find).with('ZZZ', :cast => true).and_return(mock_update)
        ActiveFedora::Base.reindex_everything
     end
 
-    it "should accept a query param for the search" do
-       query_string = "pid~*"
-       Rubydora::Repository.any_instance.should_receive(:search).with(query_string).
-            and_yield(double(pid:'XXX')).and_yield(double(pid:'YYY')).and_yield(double(pid:'ZZZ'))
+    it 'should accept a query param for the search' do
+       query_string = 'pid~*'
+       expect_any_instance_of(Rubydora::Repository).to receive(:search).with(query_string).
+            and_yield(double(pid: 'XXX')).and_yield(double(pid: 'YYY')).and_yield(double(pid: 'ZZZ'))
        mock_update = double(:mock_obj)
-       mock_update.should_receive(:update_index).exactly(3).times
-       ActiveFedora::Base.should_receive(:find).with('XXX', :cast=>true).and_return(mock_update)
-       ActiveFedora::Base.should_receive(:find).with('YYY', :cast=>true).and_return(mock_update)
-       ActiveFedora::Base.should_receive(:find).with('ZZZ', :cast=>true).and_return(mock_update)
+       expect(mock_update).to receive(:update_index).exactly(3).times
+       expect(ActiveFedora::Base).to receive(:find).with('XXX', :cast => true).and_return(mock_update)
+       expect(ActiveFedora::Base).to receive(:find).with('YYY', :cast => true).and_return(mock_update)
+       expect(ActiveFedora::Base).to receive(:find).with('ZZZ', :cast => true).and_return(mock_update)
        ActiveFedora::Base.reindex_everything(query_string)
     end
   end
 
-  describe "With a test class" do
+  describe 'With a test class' do
     before :all do
       class FooHistory < ActiveFedora::Base
-        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData", :autocreate => true do |m|
-          m.field "fubar", :string
-          m.field "swank", :text
+        has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'someData', :autocreate => true do |m|
+          m.field 'fubar', :string
+          m.field 'swank', :text
         end
-        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText", :autocreate => true do |m|
-          m.field "fubar", :text
+        has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'withText', :autocreate => true do |m|
+          m.field 'fubar', :text
         end
-        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText2", :label=>"withLabel", :autocreate => true do |m|
-          m.field "fubar", :text
-        end 
-        delegate :fubar, :to=>'withText', multiple: true
-        delegate :swank, :to=>'someData', multiple: true
+        has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'withText2', :label => 'withLabel', :autocreate => true do |m|
+          m.field 'fubar', :text
+        end
+        delegate :fubar, :to => 'withText', multiple: true
+        delegate :swank, :to => 'someData', multiple: true
       end
       class FooAdaptation < ActiveFedora::Base
-        has_metadata :type=>ActiveFedora::OmDatastream, :name=>'someData'
+        has_metadata :type => ActiveFedora::OmDatastream, :name => 'someData'
       end
 
       class FooInherited < FooHistory
@@ -150,15 +150,15 @@ describe ActiveFedora::Base do
     before(:each) do
       @this_pid = increment_pid.to_s
       stub_get(@this_pid)
-      Rubydora::Repository.any_instance.stub(:client).and_return(@mock_client)
-      ActiveFedora::Base.stub(:assign_pid).and_return(@this_pid)
+      allow_any_instance_of(Rubydora::Repository).to receive(:client).and_return(@mock_client)
+      allow(ActiveFedora::Base).to receive(:assign_pid).and_return(@this_pid)
 
       @test_object = ActiveFedora::Base.new
     end
 
     after(:each) do
       begin
-      ActiveFedora::SolrService.stub(:instance)
+      allow(ActiveFedora::SolrService).to receive(:instance)
       #@test_object.delete
       rescue
       end
@@ -166,449 +166,449 @@ describe ActiveFedora::Base do
 
 
     describe '#new' do
-      it "should create an inner object" do
+      it 'should create an inner object' do
         # for doing AFObject.new(params[:foo]) when nothing is in params[:foo]
-        Rubydora::DigitalObject.any_instance.should_receive(:save).never
+        expect_any_instance_of(Rubydora::DigitalObject).to receive(:save).never
         result = ActiveFedora::Base.new(nil)
-        result.inner_object.should be_kind_of(ActiveFedora::UnsavedDigitalObject)
+        expect(result.inner_object).to be_kind_of(ActiveFedora::UnsavedDigitalObject)
       end
 
-      it "should not save or get an pid on init" do
-        Rubydora::DigitalObject.any_instance.should_receive(:save).never
-        ActiveFedora::Base.should_receive(:assign_pid).never
+      it 'should not save or get an pid on init' do
+        expect_any_instance_of(Rubydora::DigitalObject).to receive(:save).never
+        expect(ActiveFedora::Base).to receive(:assign_pid).never
         f = FooHistory.new
       end
 
-      it "should be able to create with a custom pid" do
-        f = FooHistory.new(:pid=>'numbnuts:1')
-        f.pid.should == 'numbnuts:1'
+      it 'should be able to create with a custom pid' do
+        f = FooHistory.new(:pid => 'numbnuts:1')
+        expect(f.pid).to eq('numbnuts:1')
       end
     end
 
-    describe ".datastream_class_for_name" do
-      it "should return the specifed class" do
-        FooAdaptation.datastream_class_for_name('someData').should == ActiveFedora::OmDatastream
+    describe '.datastream_class_for_name' do
+      it 'should return the specifed class' do
+        expect(FooAdaptation.datastream_class_for_name('someData')).to eq(ActiveFedora::OmDatastream)
       end
-      it "should return the specifed class" do
-        FooAdaptation.datastream_class_for_name('content').should == ActiveFedora::Datastream
+      it 'should return the specifed class' do
+        expect(FooAdaptation.datastream_class_for_name('content')).to eq(ActiveFedora::Datastream)
       end
     end
 
-    describe ".internal_uri" do
-      it "should return pid as fedors uri" do
-        @test_object.internal_uri.should eql("info:fedora/#{@test_object.pid}")
+    describe '.internal_uri' do
+      it 'should return pid as fedors uri' do
+        expect(@test_object.internal_uri).to eql("info:fedora/#{@test_object.pid}")
       end
     end
 
     ### Methods for ActiveModel::Conversions
     it "should have to_param once it's saved" do
-      @test_object.to_param.should be_nil
+      expect(@test_object.to_param).to be_nil
       @test_object.inner_object.stub(:new? => false, :pid => 'foo:123')
-      @test_object.to_param.should == 'foo:123'
+      expect(@test_object.to_param).to eq('foo:123')
     end
 
     it "should have to_key once it's saved" do
-      @test_object.to_key.should be_nil
+      expect(@test_object.to_key).to be_nil
       @test_object.inner_object.stub(:new? => false)
-      @test_object.to_key.should == [@test_object.pid]
+      expect(@test_object.to_key).to eq([@test_object.pid])
     end
 
     it "should have to_model when it's saved" do
-      @test_object.to_model.should be @test_object
+      expect(@test_object.to_model).to be @test_object
     end
     ### end ActiveModel::Conversions
 
     ### Methods for ActiveModel::Naming
-    it "Should know the model_name" do
-      FooHistory.model_name.should == 'FooHistory'
-      FooHistory.model_name.human.should == 'Foo history'
+    it 'Should know the model_name' do
+      expect(FooHistory.model_name).to eq('FooHistory')
+      expect(FooHistory.model_name.human).to eq('Foo history')
     end
     ### End ActiveModel::Naming
 
 
-    describe ".datastreams" do
+    describe '.datastreams' do
       before do
         @test_history = FooHistory.new
       end
-      it "should create dynamic accessors" do
-        @test_history.withText.should == @test_history.datastreams['withText']
+      it 'should create dynamic accessors' do
+        expect(@test_history.withText).to eq(@test_history.datastreams['withText'])
       end
-      it "dynamic accessors should convert dashes to underscores" do
-        ds = double('datastream', :dsid=>'eac-cpf')
+      it 'dynamic accessors should convert dashes to underscores' do
+        ds = double('datastream', :dsid => 'eac-cpf')
         @test_history.add_datastream(ds)
-        @test_history.eac_cpf.should == ds
+        expect(@test_history.eac_cpf).to eq(ds)
       end
-      it "dynamic accessors should not convert datastreams named with underscore" do
-        ds = double('datastream', :dsid=>'foo_bar')
+      it 'dynamic accessors should not convert datastreams named with underscore' do
+        ds = double('datastream', :dsid => 'foo_bar')
         @test_history.add_datastream(ds)
-        @test_history.foo_bar.should == ds
+        expect(@test_history.foo_bar).to eq(ds)
       end
     end
 
     it 'should provide #find' do
-      ActiveFedora::Base.should respond_to(:find)
+      expect(ActiveFedora::Base).to respond_to(:find)
     end
 
-    it "should provide .create_date" do
-      @test_object.should respond_to(:create_date)
+    it 'should provide .create_date' do
+      expect(@test_object).to respond_to(:create_date)
     end
 
-    it "should provide .modified_date" do
-      @test_object.should respond_to(:modified_date)
+    it 'should provide .modified_date' do
+      expect(@test_object).to respond_to(:modified_date)
     end
 
     it 'should respond to .rels_ext' do
-      @test_object.should respond_to(:rels_ext)
+      expect(@test_object).to respond_to(:rels_ext)
     end
 
     describe '.rels_ext' do
 
       it 'should return the RelsExtDatastream object from the datastreams array' do
-        @test_object.stub(:datastreams => {"RELS-EXT" => "foo"})
-        @test_object.rels_ext.should == "foo"
+        @test_object.stub(:datastreams => {'RELS-EXT' => 'foo'})
+        expect(@test_object.rels_ext).to eq('foo')
       end
     end
 
     it 'should provide #add_relationship' do
-      @test_object.should respond_to(:add_relationship)
+      expect(@test_object).to respond_to(:add_relationship)
     end
 
     describe '#add_relationship' do
       it 'should call #add_relationship on the rels_ext datastream' do
-        @test_object.add_relationship("predicate", "info:fedora/object")
-        pred = ActiveFedora::Predicates.vocabularies["info:fedora/fedora-system:def/relations-external#"]["predicate"]
-        @test_object.relationships.should have_statement(RDF::Statement.new(RDF::URI.new(@test_object.internal_uri), pred, RDF::URI.new("info:fedora/object")))
+        @test_object.add_relationship('predicate', 'info:fedora/object')
+        pred = ActiveFedora::Predicates.vocabularies['info:fedora/fedora-system:def/relations-external#']['predicate']
+        expect(@test_object.relationships).to have_statement(RDF::Statement.new(RDF::URI.new(@test_object.internal_uri), pred, RDF::URI.new('info:fedora/object')))
       end
 
-      it "should update the RELS-EXT datastream and set the datastream as dirty when relationships are added" do
-        mock_ds = double("Rels-Ext")
-        mock_ds.stub(:content_will_change!)
-        @test_object.datastreams["RELS-EXT"] = mock_ds
-        @test_object.add_relationship(:is_member_of, "info:fedora/demo:5")
-        @test_object.add_relationship(:is_member_of, "info:fedora/demo:10")
+      it 'should update the RELS-EXT datastream and set the datastream as dirty when relationships are added' do
+        mock_ds = double('Rels-Ext')
+        allow(mock_ds).to receive(:content_will_change!)
+        @test_object.datastreams['RELS-EXT'] = mock_ds
+        @test_object.add_relationship(:is_member_of, 'info:fedora/demo:5')
+        @test_object.add_relationship(:is_member_of, 'info:fedora/demo:10')
       end
 
       it 'should add a relationship to an object only if it does not exist already' do
         next_pid = increment_pid.to_s
-        ActiveFedora::Base.stub(:assign_pid).and_return(next_pid)
+        allow(ActiveFedora::Base).to receive(:assign_pid).and_return(next_pid)
         stub_get(next_pid)
 
         @test_object3 = ActiveFedora::Base.new
-        @test_object.add_relationship(:has_part,@test_object3)
-        @test_object.ids_for_outbound(:has_part).should == [@test_object3.pid]
+        @test_object.add_relationship(:has_part, @test_object3)
+        expect(@test_object.ids_for_outbound(:has_part)).to eq([@test_object3.pid])
         #try adding again and make sure not there twice
-        @test_object.add_relationship(:has_part,@test_object3)
-        @test_object.ids_for_outbound(:has_part).should == [@test_object3.pid]
+        @test_object.add_relationship(:has_part, @test_object3)
+        expect(@test_object.ids_for_outbound(:has_part)).to eq([@test_object3.pid])
       end
 
       it 'should add literal relationships if requested' do
-        @test_object.add_relationship(:conforms_to,"AnInterface",true)
-        @test_object.ids_for_outbound(:conforms_to).should == ["AnInterface"]
+        @test_object.add_relationship(:conforms_to, 'AnInterface', true)
+        expect(@test_object.ids_for_outbound(:conforms_to)).to eq(['AnInterface'])
       end
     end
 
     it 'should provide #remove_relationship' do
-      @test_object.should respond_to(:remove_relationship)
+      expect(@test_object).to respond_to(:remove_relationship)
     end
 
     describe '#remove_relationship' do
       it 'should remove a relationship from the relationships hash' do
         @test_object3 = ActiveFedora::Base.new()
-        @test_object3.stub(:pid=>'7')
+        @test_object3.stub(:pid => '7')
         @test_object4 = ActiveFedora::Base.new()
-        @test_object4.stub(:pid=>'8')
-        @test_object.add_relationship(:has_part,@test_object3)
-        @test_object.add_relationship(:has_part,@test_object4)
+        @test_object4.stub(:pid => '8')
+        @test_object.add_relationship(:has_part, @test_object3)
+        @test_object.add_relationship(:has_part, @test_object4)
         #check both are there
-        @test_object.ids_for_outbound(:has_part).should == [@test_object3.pid,@test_object4.pid]
-        @test_object.remove_relationship(:has_part,@test_object3)
+        expect(@test_object.ids_for_outbound(:has_part)).to eq([@test_object3.pid, @test_object4.pid])
+        @test_object.remove_relationship(:has_part, @test_object3)
         #check only one item removed
-        @test_object.ids_for_outbound(:has_part).should == [@test_object4.pid]
-        @test_object.remove_relationship(:has_part,@test_object4)
+        expect(@test_object.ids_for_outbound(:has_part)).to eq([@test_object4.pid])
+        @test_object.remove_relationship(:has_part, @test_object4)
         #check last item removed and predicate removed since now emtpy
-        @test_object.relationships.size.should == 0
+        expect(@test_object.relationships.size).to eq(0)
       end
     end
 
     it 'should provide #relationships' do
-      @test_object.should respond_to(:relationships)
+      expect(@test_object).to respond_to(:relationships)
     end
 
     describe '#relationships' do
       it 'should return a graph' do
-        @test_object.relationships.kind_of?(RDF::Graph).should be_true
-        @test_object.relationships.size.should == 0
+        expect(@test_object.relationships.kind_of?(RDF::Graph)).to be_truthy
+        expect(@test_object.relationships.size).to eq(0)
       end
     end
 
     describe '.assert_content_model' do
-      it "should default to the name of the class" do
+      it 'should default to the name of the class' do
         stub_get(@this_pid)
         stub_add_ds(@this_pid, ['RELS-EXT'])
         @test_object.assert_content_model
-        @test_object.relationships(:has_model).should == ["info:fedora/afmodel:ActiveFedora_Base"]
+        expect(@test_object.relationships(:has_model)).to eq(['info:fedora/afmodel:ActiveFedora_Base'])
 
       end
     end
 
     describe '.save' do
-      it "should create a new record" do
+      it 'should create a new record' do
         @test_object.stub(:new_record? => true)
-        @test_object.should_receive(:create)
-        @test_object.should_receive(:update_index)
+        expect(@test_object).to receive(:create)
+        expect(@test_object).to receive(:update_index)
         @test_object.save
       end
 
-      it "should update an existing record" do
+      it 'should update an existing record' do
         @test_object.stub(:new_record? => false)
-        @test_object.should_receive(:update_record)
-        @test_object.should_receive(:update_index)
+        expect(@test_object).to receive(:update_record)
+        expect(@test_object).to receive(:update_index)
         @test_object.save
       end
     end
 
-    describe "#create" do
-      it "should build a new record and save it" do
+    describe '#create' do
+      it 'should build a new record and save it' do
         obj = double()
-        obj.should_receive(:save)
-        FooHistory.should_receive(:new).and_return(obj)
-        @hist = FooHistory.create(:fubar=>'ta', :swank=>'da')
+        expect(obj).to receive(:save)
+        expect(FooHistory).to receive(:new).and_return(obj)
+        @hist = FooHistory.create(:fubar => 'ta', :swank => 'da')
       end
 
     end
 
-    describe ".adapt_to" do
-      it "should return an adapted object of the requested type" do
+    describe '.adapt_to' do
+      it 'should return an adapted object of the requested type' do
         @test_object = FooHistory.new()
-        @test_object.adapt_to(FooAdaptation).class.should == FooAdaptation
+        expect(@test_object.adapt_to(FooAdaptation).class).to eq(FooAdaptation)
       end
-      it "should not make an additional call to fedora to create the adapted object" do
+      it 'should not make an additional call to fedora to create the adapted object' do
         @test_object = FooHistory.new()
         adapted = @test_object.adapt_to(FooAdaptation)
       end
-      it "should propagate new datastreams to the adapted object" do
+      it 'should propagate new datastreams to the adapted object' do
         @test_object = FooHistory.new()
-        @test_object.add_file_datastream("XXX", :dsid=>'MY_DSID')
+        @test_object.add_file_datastream('XXX', :dsid => 'MY_DSID')
         adapted = @test_object.adapt_to(FooAdaptation)
-        adapted.datastreams.keys.should include 'MY_DSID'
-        adapted.datastreams['MY_DSID'].content.should == "XXX"
-        adapted.datastreams['MY_DSID'].changed?.should be_true
+        expect(adapted.datastreams.keys).to include 'MY_DSID'
+        expect(adapted.datastreams['MY_DSID'].content).to eq('XXX')
+        expect(adapted.datastreams['MY_DSID'].changed?).to be_truthy
       end
-      it "should propagate modified datastreams to the adapted object" do
+      it 'should propagate modified datastreams to the adapted object' do
         @test_object = FooHistory.new()
         orig_ds = @test_object.datastreams['someData']
-        orig_ds.content="<YYY/>"
+        orig_ds.content = '<YYY/>'
         adapted = @test_object.adapt_to(FooAdaptation)
-        adapted.datastreams.keys.should include 'someData'
-        adapted.datastreams['someData'].should == orig_ds
-        adapted.datastreams['someData'].content.strip.should == "<YYY/>"
-        adapted.datastreams['someData'].changed?.should be_true
+        expect(adapted.datastreams.keys).to include 'someData'
+        expect(adapted.datastreams['someData']).to eq(orig_ds)
+        expect(adapted.datastreams['someData'].content.strip).to eq('<YYY/>')
+        expect(adapted.datastreams['someData'].changed?).to be_truthy
       end
-      it "should use the datastream definitions from the adapted object" do
+      it 'should use the datastream definitions from the adapted object' do
         @test_object = FooHistory.new()
         adapted = @test_object.adapt_to(FooAdaptation)
-        adapted.datastreams.keys.should include 'someData'
-        adapted.datastreams['someData'].class.should == ActiveFedora::OmDatastream
+        expect(adapted.datastreams.keys).to include 'someData'
+        expect(adapted.datastreams['someData'].class).to eq(ActiveFedora::OmDatastream)
       end
     end
 
-    describe ".adapt_to_cmodel with implemented (non-ActiveFedora::Base) cmodel" do
+    describe '.adapt_to_cmodel with implemented (non-ActiveFedora::Base) cmodel' do
       subject { FooHistory.new }
 
-      it "should not cast to a random first cmodel if it has a specific cmodel already" do
-        ActiveFedora::ContentModel.should_receive(:known_models_for).with(subject).and_return([FooAdaptation])
-        subject.adapt_to_cmodel.should be_kind_of FooHistory
+      it 'should not cast to a random first cmodel if it has a specific cmodel already' do
+        expect(ActiveFedora::ContentModel).to receive(:known_models_for).with(subject).and_return([FooAdaptation])
+        expect(subject.adapt_to_cmodel).to be_kind_of FooHistory
       end
-      it "should cast to an inherited model over a random one" do
-        ActiveFedora::ContentModel.should_receive(:known_models_for).with(subject).and_return([FooAdaptation, FooInherited])
-        subject.adapt_to_cmodel.should be_kind_of FooInherited
+      it 'should cast to an inherited model over a random one' do
+        expect(ActiveFedora::ContentModel).to receive(:known_models_for).with(subject).and_return([FooAdaptation, FooInherited])
+        expect(subject.adapt_to_cmodel).to be_kind_of FooInherited
       end
-      it "should not cast when a cmodel is same as the class" do
-        ActiveFedora::ContentModel.should_receive(:known_models_for).with(subject).and_return([FooHistory])
-        subject.adapt_to_cmodel.should === subject
+      it 'should not cast when a cmodel is same as the class' do
+        expect(ActiveFedora::ContentModel).to receive(:known_models_for).with(subject).and_return([FooHistory])
+        expect(subject.adapt_to_cmodel).to be === subject
       end
     end
 
-    describe ".adapt_to_cmodel with ActiveFedora::Base" do
+    describe '.adapt_to_cmodel with ActiveFedora::Base' do
       subject { ActiveFedora::Base.new }
 
-      it "should cast to the first cmodel if ActiveFedora::Base (or no specified cmodel)" do
-        ActiveFedora::ContentModel.should_receive(:known_models_for).with(subject).and_return([FooAdaptation, FooHistory])
-        subject.adapt_to_cmodel.should be_kind_of FooAdaptation
+      it 'should cast to the first cmodel if ActiveFedora::Base (or no specified cmodel)' do
+        expect(ActiveFedora::ContentModel).to receive(:known_models_for).with(subject).and_return([FooAdaptation, FooHistory])
+        expect(subject.adapt_to_cmodel).to be_kind_of FooAdaptation
       end
     end
 
 
-    describe ".to_solr" do
-      it "should provide .to_solr" do
-        @test_object.should respond_to(:to_solr)
+    describe '.to_solr' do
+      it 'should provide .to_solr' do
+        expect(@test_object).to respond_to(:to_solr)
       end
 
-      it "should add pid, system_create_date, system_modified_date and object_state from object attributes" do
-        @test_object.should_receive(:create_date).and_return("2012-03-04T03:12:02Z")
-        @test_object.should_receive(:modified_date).and_return("2012-03-07T03:12:02Z")
+      it 'should add pid, system_create_date, system_modified_date and object_state from object attributes' do
+        expect(@test_object).to receive(:create_date).and_return('2012-03-04T03:12:02Z')
+        expect(@test_object).to receive(:modified_date).and_return('2012-03-07T03:12:02Z')
         @test_object.stub(pid: 'changeme:123')
-        @test_object.state = "D"
+        @test_object.state = 'D'
         solr_doc = @test_object.to_solr
-        solr_doc[ActiveFedora::SolrService.solr_name("system_create", :stored_sortable, type: :date)].should eql("2012-03-04T03:12:02Z")
-        solr_doc[ActiveFedora::SolrService.solr_name("system_modified", :stored_sortable, type: :date)].should eql("2012-03-07T03:12:02Z")
-        solr_doc[ActiveFedora::SolrService.solr_name("object_state", :stored_sortable)].should eql("D")
-        solr_doc[:id].should eql("changeme:123")
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('system_create', :stored_sortable, type: :date)]).to eql('2012-03-04T03:12:02Z')
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('system_modified', :stored_sortable, type: :date)]).to eql('2012-03-07T03:12:02Z')
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('object_state', :stored_sortable)]).to eql('D')
+        expect(solr_doc[:id]).to eql('changeme:123')
       end
 
-      it "should omit base metadata and RELS-EXT if :model_only==true" do
-        @test_object.add_relationship(:has_part, "foo", true)
-        solr_doc = @test_object.to_solr(Hash.new, :model_only => true)
-        solr_doc[ActiveFedora::SolrService.solr_name("system_create", type: :date)].should be_nil
-        solr_doc[ActiveFedora::SolrService.solr_name("system_modified", type: :date)].should be_nil
-        solr_doc["id"].should be_nil
-        solr_doc[ActiveFedora::SolrService.solr_name("has_part", :symbol)].should be_nil
+      it 'should omit base metadata and RELS-EXT if :model_only==true' do
+        @test_object.add_relationship(:has_part, 'foo', true)
+        solr_doc = @test_object.to_solr({}, :model_only => true)
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('system_create', type: :date)]).to be_nil
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('system_modified', type: :date)]).to be_nil
+        expect(solr_doc['id']).to be_nil
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('has_part', :symbol)]).to be_nil
       end
 
-      it "should add self.class as the :active_fedora_model" do
+      it 'should add self.class as the :active_fedora_model' do
         stub_get(@this_pid)
         stub_get_content(@this_pid, ['RELS-EXT', 'someData', 'withText2', 'withText'])
         @test_history = FooHistory.new()
         solr_doc = @test_history.to_solr
-        solr_doc[ActiveFedora::SolrService.solr_name("active_fedora_model", :stored_sortable)].should eql("FooHistory")
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('active_fedora_model', :stored_sortable)]).to eql('FooHistory')
       end
 
-      it "should call .to_solr on all SimpleDatastreams and OmDatastreams, passing the resulting document to solr" do
-        mock1 = double("ds1", :to_solr => {})
-        mock2 = double("ds2", :to_solr => {})
-        ngds = double("ngds", :to_solr => {})
-        ngds.should_receive(:solrize_profile)
-        mock1.should_receive(:solrize_profile)
-        mock2.should_receive(:solrize_profile)
+      it 'should call .to_solr on all SimpleDatastreams and OmDatastreams, passing the resulting document to solr' do
+        mock1 = double('ds1', :to_solr => {})
+        mock2 = double('ds2', :to_solr => {})
+        ngds = double('ngds', :to_solr => {})
+        expect(ngds).to receive(:solrize_profile)
+        expect(mock1).to receive(:solrize_profile)
+        expect(mock2).to receive(:solrize_profile)
 
-        @test_object.should_receive(:datastreams).twice.and_return({:ds1 => mock1, :ds2 => mock2, :ngds => ngds})
-        @test_object.should_receive(:solrize_relationships)
+        expect(@test_object).to receive(:datastreams).twice.and_return({:ds1 => mock1, :ds2 => mock2, :ngds => ngds})
+        expect(@test_object).to receive(:solrize_relationships)
         @test_object.to_solr
       end
-      it "should call .to_solr on all RDFDatastreams, passing the resulting document to solr" do
-        mock = double("ds1", :to_solr => {})
-        mock.should_receive(:solrize_profile)
+      it 'should call .to_solr on all RDFDatastreams, passing the resulting document to solr' do
+        mock = double('ds1', :to_solr => {})
+        expect(mock).to receive(:solrize_profile)
 
-        @test_object.should_receive(:datastreams).twice.and_return({:ds1 => mock})
-        @test_object.should_receive(:solrize_relationships)
+        expect(@test_object).to receive(:datastreams).twice.and_return({:ds1 => mock})
+        expect(@test_object).to receive(:solrize_relationships)
         @test_object.to_solr
       end
 
-      it "should call .to_solr on the relationships rels-ext is dirty" do
-        @test_object.add_relationship(:has_collection_member, "info:fedora/test:member")
+      it 'should call .to_solr on the relationships rels-ext is dirty' do
+        @test_object.add_relationship(:has_collection_member, 'info:fedora/test:member')
         rels_ext = @test_object.rels_ext
-        rels_ext.should be_changed
-        @test_object.should_receive(:solrize_relationships)
+        expect(rels_ext).to be_changed
+        expect(@test_object).to receive(:solrize_relationships)
         @test_object.to_solr
       end
 
     end
 
-    describe ".label" do
-      it "should return the label of the inner object" do
-        @test_object.inner_object.should_receive(:label).and_return("foo label")
-        @test_object.label.should == "foo label"
+    describe '.label' do
+      it 'should return the label of the inner object' do
+        expect(@test_object.inner_object).to receive(:label).and_return('foo label')
+        expect(@test_object.label).to eq('foo label')
       end
     end
 
-    describe ".label=" do
-      it "should set the label of the inner object" do
-        @test_object.label.should_not == "foo label"
-        @test_object.label = "foo label"
-        @test_object.label.should == "foo label"
+    describe '.label=' do
+      it 'should set the label of the inner object' do
+        expect(@test_object.label).not_to eq('foo label')
+        @test_object.label = 'foo label'
+        expect(@test_object.label).to eq('foo label')
       end
     end
 
 
-    describe "get_values_from_datastream" do
-      it "should look up the named datastream and call get_values with the given pointer/field_name" do
-        mock_ds = double("Datastream", :get_values=>["value1", "value2"])
-        @test_object.stub(:datastreams).and_return({"ds1"=>mock_ds})
-        @test_object.get_values_from_datastream("ds1", "--my xpath--").should == ["value1", "value2"]
+    describe 'get_values_from_datastream' do
+      it 'should look up the named datastream and call get_values with the given pointer/field_name' do
+        mock_ds = double('Datastream', :get_values => ['value1', 'value2'])
+        allow(@test_object).to receive(:datastreams).and_return({'ds1' => mock_ds})
+        expect(@test_object.get_values_from_datastream('ds1', '--my xpath--')).to eq(['value1', 'value2'])
       end
     end
 
-    describe "update_datastream_attributes" do
-      it "should look up any datastreams specified as keys in the given hash and call update_attributes on the datastream" do
-        mock_desc_metadata = double("descMetadata")
-        mock_properties = double("properties")
-        mock_ds_hash = {'descMetadata'=>mock_desc_metadata, 'properties'=>mock_properties}
+    describe 'update_datastream_attributes' do
+      it 'should look up any datastreams specified as keys in the given hash and call update_attributes on the datastream' do
+        mock_desc_metadata = double('descMetadata')
+        mock_properties = double('properties')
+        mock_ds_hash = {'descMetadata' => mock_desc_metadata, 'properties' => mock_properties}
 
         ds_values_hash = {
-          "descMetadata"=>{ [{:person=>0}, :role]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"} },
-          "properties"=>{ "notes"=>"foo" }
+          'descMetadata' => { [{:person => 0}, :role] => {'0' => 'role1', '1' => 'role2', '2' => 'role3'} },
+          'properties' => { 'notes' => 'foo' }
         }
         m = FooHistory.new
-        m.stub(:datastreams).and_return(mock_ds_hash)
-        mock_desc_metadata.should_receive(:update_indexed_attributes).with( ds_values_hash['descMetadata'] )
-        mock_properties.should_receive(:update_indexed_attributes).with( ds_values_hash['properties'] )
+        allow(m).to receive(:datastreams).and_return(mock_ds_hash)
+        expect(mock_desc_metadata).to receive(:update_indexed_attributes).with( ds_values_hash['descMetadata'] )
+        expect(mock_properties).to receive(:update_indexed_attributes).with( ds_values_hash['properties'] )
         m.update_datastream_attributes( ds_values_hash )
       end
-      it "should not do anything and should return an empty hash if the specified datastream does not exist" do
-pending "This is broken, and deprecated.  I don't want to fix it - jcoyne"
+      it 'should not do anything and should return an empty hash if the specified datastream does not exist' do
+skip "This is broken, and deprecated.  I don't want to fix it - jcoyne"
         ds_values_hash = {
-          "nonexistentDatastream"=>{ "notes"=>"foo" }
+          'nonexistentDatastream' => { 'notes' => 'foo' }
         }
         m = FooHistory.new
         untouched_xml = m.to_xml
-        m.update_datastream_attributes( ds_values_hash ).should == {}
-        m.to_xml.should == untouched_xml
+        expect(m.update_datastream_attributes( ds_values_hash )).to eq({})
+        expect(m.to_xml).to eq(untouched_xml)
       end
     end
 
-    describe "update_attributes" do
-      it "should set the attributes and save" do
+    describe 'update_attributes' do
+      it 'should set the attributes and save' do
         m = FooHistory.new
-        att= {"fubar"=> '1234', "baz" =>'stuff'}
+        att = {'fubar' => '1234', 'baz' => 'stuff'}
 
-        m.should_receive(:fubar=).with('1234')
-        m.should_receive(:baz=).with('stuff')
-        m.should_receive(:save)
+        expect(m).to receive(:fubar=).with('1234')
+        expect(m).to receive(:baz=).with('stuff')
+        expect(m).to receive(:save)
         m.update_attributes(att)
       end
     end
 
-    describe "update" do
-      it "should set the attributes and save" do
+    describe 'update' do
+      it 'should set the attributes and save' do
         m = FooHistory.new
-        att= {"fubar"=> '1234', "baz" =>'stuff'}
+        att = {'fubar' => '1234', 'baz' => 'stuff'}
 
-        m.should_receive(:fubar=).with('1234')
-        m.should_receive(:baz=).with('stuff')
-        m.should_receive(:save)
+        expect(m).to receive(:fubar=).with('1234')
+        expect(m).to receive(:baz=).with('stuff')
+        expect(m).to receive(:save)
         m.update(att)
       end
     end
 
-    describe "update_indexed_attributes" do
+    describe 'update_indexed_attributes' do
       before do
-        Deprecation.should_receive(:warn).at_least(1).times
+        expect(Deprecation).to receive(:warn).at_least(1).times
       end
-      it "should call .update_indexed_attributes on all metadata datastreams & nokogiri datastreams" do
+      it 'should call .update_indexed_attributes on all metadata datastreams & nokogiri datastreams' do
         m = FooHistory.new
-        att= {"fubar"=>{"-1"=>"mork", "0"=>"york", "1"=>"mangle"}}
+        att = {'fubar' => {'-1' => 'mork', '0' => 'york', '1' => 'mangle'}}
 
-        m.datastreams['someData'].should_receive(:update_indexed_attributes)
-        m.datastreams["withText"].should_receive(:update_indexed_attributes)
-        m.datastreams['withText2'].should_receive(:update_indexed_attributes)
+        expect(m.datastreams['someData']).to receive(:update_indexed_attributes)
+        expect(m.datastreams['withText']).to receive(:update_indexed_attributes)
+        expect(m.datastreams['withText2']).to receive(:update_indexed_attributes)
         m.update_indexed_attributes(att)
       end
-      it "should take a :datastreams argument" do
-        att= {"fubar"=>{"-1"=>"mork", "0"=>"york", "1"=>"mangle"}}
+      it 'should take a :datastreams argument' do
+        att = {'fubar' => {'-1' => 'mork', '0' => 'york', '1' => 'mangle'}}
         stub_get(@this_pid)
         stub_get_content(@this_pid, ['RELS-EXT', 'someData', 'withText2', 'withText'])
         m = FooHistory.new()
-        m.update_indexed_attributes(att, :datastreams=>"withText")
-        m.should_not be_nil
-        m.datastreams['someData'].fubar.should == []
-        m.datastreams["withText"].fubar.should == ['mork', 'york', 'mangle']
-        m.datastreams['withText2'].fubar.should == []
+        m.update_indexed_attributes(att, :datastreams => 'withText')
+        expect(m).not_to be_nil
+        expect(m.datastreams['someData'].fubar).to eq([])
+        expect(m.datastreams['withText'].fubar).to eq(['mork', 'york', 'mangle'])
+        expect(m.datastreams['withText2'].fubar).to eq([])
 
-        att= {"fubar"=>{"-1"=>"tork", "0"=>"work", "1"=>"bork"}}
-        m.update_indexed_attributes(att, :datastreams=>["someData", "withText2"])
-        m.should_not be_nil
-        m.datastreams['someData'].fubar.should == ['tork', 'work', 'bork']
-        m.datastreams['withText2'].fubar.should == ['tork', 'work', 'bork']
+        att = {'fubar' => {'-1' => 'tork', '0' => 'work', '1' => 'bork'}}
+        m.update_indexed_attributes(att, :datastreams => ['someData', 'withText2'])
+        expect(m).not_to be_nil
+        expect(m.datastreams['someData'].fubar).to eq(['tork', 'work', 'bork'])
+        expect(m.datastreams['withText2'].fubar).to eq(['tork', 'work', 'bork'])
       end
     end
 
@@ -622,21 +622,21 @@ pending "This is broken, and deprecated.  I don't want to fix it - jcoyne"
       end
     end
 
-    describe ".solrize_relationships" do
-      it "should serialize the relationships into a Hash" do
+    describe '.solrize_relationships' do
+      it 'should serialize the relationships into a Hash' do
         graph = RDF::Graph.new
-        subject = RDF::URI.new "info:fedora/test:sample_pid"
+        subject = RDF::URI.new 'info:fedora/test:sample_pid'
         graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:is_member_of),  RDF::URI.new('info:fedora/demo:10'))
         graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:is_part_of),  RDF::URI.new('info:fedora/demo:11'))
         graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_part),  RDF::URI.new('info:fedora/demo:12'))
-        graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:conforms_to),  "AnInterface")
+        graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:conforms_to),  'AnInterface')
 
-        @test_object.should_receive(:relationships).and_return(graph)
+        expect(@test_object).to receive(:relationships).and_return(graph)
         solr_doc = @test_object.solrize_relationships
-        solr_doc[ActiveFedora::SolrService.solr_name("is_member_of", :symbol)].should == "info:fedora/demo:10"
-        solr_doc[ActiveFedora::SolrService.solr_name("is_part_of", :symbol)].should == "info:fedora/demo:11"
-        solr_doc[ActiveFedora::SolrService.solr_name("has_part", :symbol)].should == "info:fedora/demo:12"
-        solr_doc[ActiveFedora::SolrService.solr_name("conforms_to", :symbol)].should == "AnInterface"
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('is_member_of', :symbol)]).to eq('info:fedora/demo:10')
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('is_part_of', :symbol)]).to eq('info:fedora/demo:11')
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('has_part', :symbol)]).to eq('info:fedora/demo:12')
+        expect(solr_doc[ActiveFedora::SolrService.solr_name('conforms_to', :symbol)]).to eq('AnInterface')
       end
     end
   end