active-fedora 8.2.1 → 8.2.2

data/spec/unit/attributes_spec.rb

@@ -69,7 +69,7 @@ describe ActiveFedora::Base do
         expect(subject.inspect).to eq "#<BarHistory2 pid: nil, cow: \"\", fubar: [], pig: nil, horse: [], duck: [\"\"], animal_id: nil>"
       end
       describe "with a pid" do
-        before { subject.stub(pid: 'test:123') }
+        before { allow(subject).to receive_messages(pid: 'test:123') }
         it "should show a pid" do
           expect(subject.inspect).to eq "#<BarHistory2 pid: \"test:123\", cow: \"\", fubar: [], pig: nil, horse: [], duck: [\"\"], animal_id: nil>"
         end
@@ -108,58 +108,58 @@ describe ActiveFedora::Base do
     end
 
     it "should reveal the unique properties" do
-      BarHistory2.unique?(:horse).should be false
-      BarHistory2.unique?(:pig).should be true
-      BarHistory2.unique?(:cow).should be true
+      expect(BarHistory2.unique?(:horse)).to be false
+      expect(BarHistory2.unique?(:pig)).to be true
+      expect(BarHistory2.unique?(:cow)).to be true
     end
 
     it "should save a delegated property uniquely" do
       subject.fubar = ["Quack"]
-      subject.fubar.should == ["Quack"]
-      subject.withText.get_values(:fubar).first.should == 'Quack'
+      expect(subject.fubar).to eq(["Quack"])
+      expect(subject.withText.get_values(:fubar).first).to eq('Quack')
       subject.cow = "Low"
-      subject.cow.should == "Low"
-      subject.xmlish.term_values(:cow).first.should == 'Low'
+      expect(subject.cow).to eq("Low")
+      expect(subject.xmlish.term_values(:cow).first).to eq('Low')
 
       subject.pig = "Oink"
-      subject.pig.should == "Oink"
+      expect(subject.pig).to eq("Oink")
     end
 
     it "should allow passing parameters to the delegate accessor" do
       subject.fubar = ["one", "two"]
-      subject.fubar(1).should == ['two']
+      expect(subject.fubar(1)).to eq(['two'])
     end
 
     it "should return an array if marked as multiple" do
       subject.horse=["neigh", "whinny"]
-      subject.horse.should == ["neigh", "whinny"]
+      expect(subject.horse).to eq(["neigh", "whinny"])
     end
 
     it "should be able to delegate deeply into the terminology" do
       subject.duck = ["Quack", "Peep"]
-      subject.duck.should == ["Quack", "Peep"]
+      expect(subject.duck).to eq(["Quack", "Peep"])
     end
 
     it "should be able to track change status" do
-      subject.fubar_changed?.should be false
+      expect(subject.fubar_changed?).to be false
       subject.fubar = ["Meow"]
-      subject.fubar_changed?.should be true
+      expect(subject.fubar_changed?).to be true
     end
 
     describe "array getters and setters" do
       it "should accept symbol keys" do
         subject[:duck] = ["Cluck", "Gobble"]
-        subject[:duck].should == ["Cluck", "Gobble"]
+        expect(subject[:duck]).to eq(["Cluck", "Gobble"])
       end
 
       it "should accept string keys" do
         subject['duck'] = ["Cluck", "Gobble"]
-        subject['duck'].should == ["Cluck", "Gobble"]
+        expect(subject['duck']).to eq(["Cluck", "Gobble"])
       end
 
       it "should accept field names with _id that are not associations" do
         subject['animal_id'] = "lemur"
-        subject['animal_id'].should == "lemur"
+        expect(subject['animal_id']).to eq("lemur")
       end
 
       it "should raise an error on the reader when the field isn't delegated" do
@@ -206,13 +206,13 @@ describe ActiveFedora::Base do
 
     it "should be able to delegate deeply into the terminology" do
       subject.donkey = ["Bray", "Hee-haw"]
-      subject.donkey.should == ["Bray", "Hee-haw"]
+      expect(subject.donkey).to eq(["Bray", "Hee-haw"])
     end
 
     it "should be able to track change status" do
-      subject.cow_changed?.should be false
+      expect(subject.cow_changed?).to be false
       subject.cow = ["Moo"]
-      subject.cow_changed?.should be true
+      expect(subject.cow_changed?).to be true
     end 
   end
 
@@ -247,9 +247,9 @@ describe ActiveFedora::Base do
 
     describe "with a multivalued field" do
       it "should be able to track change status" do
-        subject.title_changed?.should be false
+        expect(subject.title_changed?).to be false
         subject.title = ["Title1", "Title2"]
-        subject.title_changed?.should be true
+        expect(subject.title_changed?).to be true
       end
       it "should not accept a single literal value" do
         expect { subject.title = "Title1" }.to raise_error
@@ -261,9 +261,9 @@ describe ActiveFedora::Base do
     end
     describe "with a single-valued field" do
       it "should be able to track change status" do
-        subject.description_changed?.should be false
+        expect(subject.description_changed?).to be false
         subject.description = "A brief description"
-        subject.description_changed?.should be true
+        expect(subject.description_changed?).to be true
       end
       it "should not accept an array of literal values" do
         expect { subject.description = ["A brief description", "A longer description"] }.to raise_error

data/spec/unit/base_active_model_spec.rb

@@ -37,18 +37,18 @@ describe ActiveFedora::Base do
     describe "attributes=" do
       it "should set attributes" do
         @n.attributes = {:fubar=>"baz", :duck=>"Quack"}
-        @n.fubar.should == "baz"
-        @n.withText.get_values(:fubar).first.should == 'baz'
-        @n.duck.should == "Quack"
-        @n.xmlish.term_values(:duck).first.should == 'Quack'
+        expect(@n.fubar).to eq("baz")
+        expect(@n.withText.get_values(:fubar).first).to eq('baz')
+        expect(@n.duck).to eq("Quack")
+        expect(@n.xmlish.term_values(:duck).first).to eq('Quack')
       end
     end
     describe "update_attributes" do
       it "should set attributes and save " do
         @n.update_attributes(:fubar=>"baz", :duck=>"Quack")
         @q = BarHistory.find(@n.pid)
-        @q.fubar.should == "baz"
-        @q.duck.should == "Quack"
+        expect(@q.fubar).to eq("baz")
+        expect(@q.duck).to eq("Quack")
       end
       after do
         @n.delete

data/spec/unit/base_cma_spec.rb

@@ -9,8 +9,8 @@ describe ActiveFedora::Base do
   describe '.save' do
 
     it "should add hasModel relationship that points to the CModel if @new_object" do
-      @test_object.stub(:update_index)
-      @test_object.should_receive(:refresh)
+      allow(@test_object).to receive(:update_index)
+      expect(@test_object).to receive(:refresh)
       @test_object.save
     end
   end

data/spec/unit/base_datastream_management_spec.rb

@@ -9,25 +9,25 @@ describe ActiveFedora::Base do
   describe '.add_datastream' do
     it "should not call Datastream.save" do
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
-      ds.should_receive(:save).never
+      expect(ds).to receive(:save).never
       @test_object.add_datastream(ds)
     end
     it "should add the datastream to the datastreams_in_memory array" do
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
-      @test_object.datastreams.should_not have_key(ds.dsid)
+      expect(@test_object.datastreams).not_to have_key(ds.dsid)
       @test_object.add_datastream(ds)
-      @test_object.datastreams.should have_key(ds.dsid)
+      expect(@test_object.datastreams).to have_key(ds.dsid)
     end
     it "should auto-assign dsids using auto-incremented integers if dsid is nil or an empty string" do 
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, nil)
-      ds.dsid.should == 'DS1'
-      @test_object.add_datastream(ds).should == 'DS1'
+      expect(ds.dsid).to eq('DS1')
+      expect(@test_object.add_datastream(ds)).to eq('DS1')
       ds_emptystringid = ActiveFedora::Datastream.new(@test_object.inner_object, '')
-      @test_object.add_datastream(ds_emptystringid).should == 'DS2'
+      expect(@test_object.add_datastream(ds_emptystringid)).to eq('DS2')
     end
     it "should accept a prefix option and apply it to automatically assigned dsids" do
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, nil, :prefix=> "FOO")
-      ds.dsid.should == 'FOO1'
+      expect(ds.dsid).to eq('FOO1')
     end
   end
 end

data/spec/unit/base_extra_spec.rb

@@ -9,12 +9,12 @@ describe ActiveFedora::Base do
   describe ".update_index" do
     before do
       mock_conn = double("SolrConnection")
-      mock_conn.should_receive(:add) do |_, opts|
-        opts.should == {:params=>{:softCommit=>true}}
+      expect(mock_conn).to receive(:add) do |_, opts|
+        expect(opts).to eq({:params=>{:softCommit=>true}})
       end
       mock_ss = double("SolrService")
-      mock_ss.stub(:conn).and_return(mock_conn)
-      ActiveFedora::SolrService.stub(:instance).and_return(mock_ss)
+      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
@@ -24,11 +24,11 @@ describe ActiveFedora::Base do
       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
 
@@ -39,11 +39,11 @@ describe ActiveFedora::Base do
       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
 
@@ -59,12 +59,12 @@ describe ActiveFedora::Base do
     end
     
     it "should delete object from repository and index" do
-      @test_object.inner_object.stub(:delete)
+      allow(@test_object.inner_object).to receive(:delete)
       mock_conn = double("SolrConnection")
-      mock_conn.should_receive(:delete_by_id).with(nil, {:params=>{"softCommit"=>true}}) 
+      expect(mock_conn).to receive(:delete_by_id).with(nil, {:params=>{"softCommit"=>true}}) 
       mock_ss = double("SolrService")
-      mock_ss.stub(:conn).and_return(mock_conn)
-      ActiveFedora::SolrService.stub(:instance).and_return(mock_ss)
+      allow(mock_ss).to receive(:conn).and_return(mock_conn)
+      allow(ActiveFedora::SolrService).to receive(:instance).and_return(mock_ss)
       @test_object.delete
     end
 
@@ -87,13 +87,13 @@ describe ActiveFedora::Base do
   
     context "with the namespace declared in the model" do
       before do
-        subject.stub(:pid_namespace).and_return("test-cModel")
+        allow(subject).to receive(:pid_namespace).and_return("test-cModel")
       end
       its(:to_class_uri) {should == 'info:fedora/test-cModel:SpecModel_CamelCased' }
     end
     context "with the suffix declared in the model" do
       before do
-        subject.stub(:pid_suffix).and_return("-TEST-SUFFIX")
+        allow(subject).to receive(:pid_suffix).and_return("-TEST-SUFFIX")
       end
       its(:to_class_uri) {should == 'info:fedora/afmodel:SpecModel_CamelCased-TEST-SUFFIX' }
     end

data/spec/unit/base_spec.rb

@@ -6,80 +6,80 @@ describe ActiveFedora::Base do
 
   describe 'descendants' do
     it "should record the decendants" do
-      ActiveFedora::Base.descendants.should include(ModsArticle, SpecialThing)
+      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
+      expect(ActiveFedora::Base.shard_index(@this_pid)).to eq(0)
     end
 
     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')
-        Rubydora::Fc3Service.any_instance.stub(:repository_profile)
+        allow(ActiveFedora.config).to receive(:credentials).and_return(:url=>'myfedora')
+        allow_any_instance_of(Rubydora::Fc3Service).to receive(:repository_profile)
       end
-      it { should be_kind_of Rubydora::Repository}
+      it { is_expected.to be_kind_of Rubydora::Repository}
       it "should be the standard connection" do
-        subject.client.url.should == 'myfedora'
+        expect(subject.client.url).to eq('myfedora')
       end
       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"))
+          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
+          expect(ActiveFedora::Base.shard_index('test:bar')).to eq(0)
         end
       end
     end
     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'} ])
+        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")
-          stubhard1.should_receive(:connection).and_return(double("Connection", :mint =>"sample:newpid"))
-          stubhard2.should_receive(:connection).never
+          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
+          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
         before do
-          Rubydora::Fc3Service.any_instance.stub(:repository_profile)
+          allow_any_instance_of(Rubydora::Fc3Service).to receive(:repository_profile)
         end
         describe "for test:bar" do
           subject {ActiveFedora::Base.connection_for_pid('test:bar')}
           it "should be shard1" do
-            subject.client.url.should == 'shard1'
+            expect(subject.client.url).to eq('shard1')
           end
         end
         describe "for test:baz" do
           subject {ActiveFedora::Base.connection_for_pid('test:nanana')}
           it "should be shard1" do
-            subject.client.url.should == 'shard2'
+            expect(subject.client.url).to eq('shard2')
           end
         end
       end
@@ -89,29 +89,29 @@ describe ActiveFedora::Base do
 
   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).
+       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').and_return(mock_update)
-       ActiveFedora::Base.should_receive(:find).with('YYY').and_return(mock_update)
-       ActiveFedora::Base.should_receive(:find).with('ZZZ').and_return(mock_update)
+       expect(mock_update).to receive(:update_index).exactly(3).times
+       expect(ActiveFedora::Base).to receive(:find).with('XXX').and_return(mock_update)
+       expect(ActiveFedora::Base).to receive(:find).with('YYY').and_return(mock_update)
+       expect(ActiveFedora::Base).to receive(:find).with('ZZZ').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).
+       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').and_return(mock_update)
-       ActiveFedora::Base.should_receive(:find).with('YYY').and_return(mock_update)
-       ActiveFedora::Base.should_receive(:find).with('ZZZ').and_return(mock_update)
+       expect(mock_update).to receive(:update_index).exactly(3).times
+       expect(ActiveFedora::Base).to receive(:find).with('XXX').and_return(mock_update)
+       expect(ActiveFedora::Base).to receive(:find).with('YYY').and_return(mock_update)
+       expect(ActiveFedora::Base).to receive(:find).with('ZZZ').and_return(mock_update)
        ActiveFedora::Base.reindex_everything(query_string)
     end
   end
@@ -154,15 +154,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
@@ -172,60 +172,60 @@ describe ActiveFedora::Base do
     describe '#new' 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
+        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'
+        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
+        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
+        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}")
+        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
-      @test_object.inner_object.stub(new_record?: false, pid: 'foo:123')
-      @test_object.to_param.should == 'foo:123'
+      expect(@test_object.to_param).to be_nil
+      allow(@test_object.inner_object).to receive_messages(new_record?: false, pid: '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
-      @test_object.inner_object.stub(new_record?: false, pid: 'foo:123')
-      @test_object.to_key.should == ['foo:123']
+      expect(@test_object.to_key).to be_nil
+      allow(@test_object.inner_object).to receive_messages(new_record?: false, pid: 'foo:123')
+      expect(@test_object.to_key).to eq(['foo:123'])
     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'
+      expect(FooHistory.model_name).to eq('FooHistory')
+      expect(FooHistory.model_name.human).to eq('Foo history')
     end
     ### End ActiveModel::Naming
 
@@ -233,7 +233,7 @@ describe ActiveFedora::Base do
     describe ".datastreams" do
       let(:test_history) { FooHistory.new }
       it "should create accessors for datastreams declared with has_metadata" do
-        test_history.withText.should == test_history.datastreams['withText']
+        expect(test_history.withText).to eq(test_history.datastreams['withText'])
       end
       describe "dynamic accessors" do
         before do
@@ -243,56 +243,56 @@ describe ActiveFedora::Base do
         describe "when the datastream is named with dash" do
           let(:ds) {double('datastream', :dsid=>'eac-cpf')}
           it "should convert dashes to underscores" do
-            test_history.eac_cpf.should == ds
+            expect(test_history.eac_cpf).to eq(ds)
           end
         end
         describe "when the datastream is named with underscore" do
           let (:ds) { double('datastream', :dsid=>'foo_bar') }
           it "should preserve the underscore" do
-            test_history.foo_bar.should == ds
+            expect(test_history.foo_bar).to eq(ds)
           end
         end
       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)
+      expect(@test_object).to respond_to(:create_date)
     end
 
     it "should provide .modified_date" do
-      @test_object.should respond_to(:modified_date)
+      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"
+        allow(@test_object).to receive_messages(: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")))
+        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!)
+        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")
@@ -300,54 +300,54 @@ describe ActiveFedora::Base do
 
       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]
+        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]
+        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"]
+        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')
+        allow(@test_object3).to receive_messages(:pid=>'7')
         @test_object4 = ActiveFedora::Base.new()
-        @test_object4.stub(:pid=>'8')
+        allow(@test_object4).to receive_messages(: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]
+        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]
+        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
 
@@ -356,26 +356,26 @@ describe ActiveFedora::Base 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
-        @test_object.stub(:new_record? => true)
-        @test_object.should_receive(:assign_pid)
-        @test_object.should_receive(:serialize_datastreams)
-        @test_object.inner_object.should_receive(:save)
-        @test_object.should_receive(:update_index)
+        allow(@test_object).to receive_messages(:new_record? => true)
+        expect(@test_object).to receive(:assign_pid)
+        expect(@test_object).to receive(:serialize_datastreams)
+        expect(@test_object.inner_object).to receive(:save)
+        expect(@test_object).to receive(:update_index)
         @test_object.save
       end
 
       it "should update an existing record" do
-        @test_object.stub(:new_record? => false)
-        @test_object.should_receive(:serialize_datastreams)
-        @test_object.inner_object.should_receive(:save)
-        @test_object.should_receive(:update_index)
+        allow(@test_object).to receive_messages(:new_record? => false)
+        expect(@test_object).to receive(:serialize_datastreams)
+        expect(@test_object.inner_object).to receive(:save)
+        expect(@test_object).to receive(:update_index)
         @test_object.save
       end
     end
@@ -383,8 +383,8 @@ describe ActiveFedora::Base 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)
+        expect(obj).to receive(:save)
+        expect(FooHistory).to receive(:new).and_return(obj)
         @hist = FooHistory.create(:fubar=>'ta', :swank=>'da')
       end
 
@@ -393,7 +393,7 @@ describe ActiveFedora::Base 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
         @test_object = FooHistory.new()
@@ -403,25 +403,25 @@ describe ActiveFedora::Base do
         @test_object = FooHistory.new()
         @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
         @test_object = FooHistory.new()
         orig_ds = @test_object.datastreams['someData']
         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
         @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
 
@@ -429,16 +429,16 @@ describe ActiveFedora::Base do
       subject { FooHistory.new }
 
       it "should raise an exception if the object class is not equal to or a subclass of any known model" do
-        ActiveFedora::ContentModel.should_receive(:known_models_for).with(subject).and_return([FooAdaptation])
+        expect(ActiveFedora::ContentModel).to receive(:known_models_for).with(subject).and_return([FooAdaptation])
         expect { subject.adapt_to_cmodel }.to raise_error(ActiveFedora::ModelNotAsserted)
       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
+        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
+        expect(ActiveFedora::ContentModel).to receive(:known_models_for).with(subject).and_return([FooHistory])
+        expect(subject.adapt_to_cmodel).to be === subject
       end
     end
 
@@ -446,36 +446,36 @@ describe 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
+        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)
+        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")
-        @test_object.stub(pid: 'changeme:123')
+        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")
+        allow(@test_object).to receive_messages(pid: 'changeme:123')
         @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
+        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
@@ -483,35 +483,35 @@ describe ActiveFedora::Base do
         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)
+        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)
+        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")
         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
 
@@ -519,16 +519,16 @@ describe ActiveFedora::Base do
 
     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"
+        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"
+        expect(@test_object.label).not_to eq("foo label")
         @test_object.label = "foo label"
-        @test_object.label.should == "foo label"
+        expect(@test_object.label).to eq("foo label")
       end
     end
     describe "update_attributes" do
@@ -536,9 +536,9 @@ describe ActiveFedora::Base do
         m = FooHistory.new
         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
@@ -548,9 +548,9 @@ describe ActiveFedora::Base do
         m = FooHistory.new
         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
@@ -564,12 +564,12 @@ describe ActiveFedora::Base do
         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")
 
-        @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