active-fedora 8.2.1 → 8.2.2

data/spec/integration/persistence_spec.rb

@@ -16,7 +16,7 @@ describe "persisting objects" do
 
   describe "#create!" do
     it "should validate" do
-      lambda { MockAFBaseRelationship.create!}.should raise_error ActiveFedora::RecordInvalid, "Validation failed: Name can't be blank"
+      expect { MockAFBaseRelationship.create!}.to raise_error ActiveFedora::RecordInvalid, "Validation failed: Name can't be blank"
     end
   end
 end

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -100,14 +100,14 @@ describe "Nesting attribute behavior of RDFDatastream" do
         subject { ComplexRDFDatastream::PersonalName.new(RDF::Graph.new) }
         it "should accept a hash" do
           subject.elementList_attributes =  [{ topicElement_attributes: {'0' => { elementValue:"Quantum Behavior" }, '1' => { elementValue:"Wave Function" }}}]
-          subject.elementList.first[0].elementValue.should == ["Quantum Behavior"]
-          subject.elementList.first[1].elementValue.should == ["Wave Function"]
+          expect(subject.elementList.first[0].elementValue).to eq(["Quantum Behavior"])
+          expect(subject.elementList.first[1].elementValue).to eq(["Wave Function"])
 
         end
         it "should accept an array" do
           subject.elementList_attributes =  [{ topicElement_attributes: [{ elementValue:"Quantum Behavior" }, { elementValue:"Wave Function" }]}]
-          subject.elementList.first[0].elementValue.should == ["Quantum Behavior"]
-          subject.elementList.first[1].elementValue.should == ["Wave Function"]
+          expect(subject.elementList.first[0].elementValue).to eq(["Quantum Behavior"])
+          expect(subject.elementList.first[1].elementValue).to eq(["Wave Function"])
         end
       end
 
@@ -118,10 +118,10 @@ describe "Nesting attribute behavior of RDFDatastream" do
         end
 
         it 'should have attributes' do
-          subject.topic[0].elementList.first[0].elementValue.should == ["Cosmology"]
-          subject.topic[1].elementList.first[0].elementValue.should == ["Quantum Behavior"]
-          subject.personalName.first.elementList.first.fullNameElement.should == ["Jefferson, Thomas"]
-          subject.personalName.first.elementList.first.dateNameElement.should == ["1743-1826"]
+          expect(subject.topic[0].elementList.first[0].elementValue).to eq(["Cosmology"])
+          expect(subject.topic[1].elementList.first[0].elementValue).to eq(["Quantum Behavior"])
+          expect(subject.personalName.first.elementList.first.fullNameElement).to eq(["Jefferson, Thomas"])
+          expect(subject.personalName.first.elementList.first.dateNameElement).to eq(["1743-1826"])
         end
         
         it 'should build nodes with ids' do
@@ -171,7 +171,7 @@ describe "Nesting attribute behavior of RDFDatastream" do
       it "should update nested objects" do
         subject.parts_attributes= [{id: replace_object_id, label: "Universal Joint"}, {label:"Oil Pump"}, {id: remove_object_id, _destroy: '1', label: "bar1 uno"}]
 
-        subject.parts.map{|p| p.label.first}.should == ['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump']
+        expect(subject.parts.map{|p| p.label.first}).to eq(['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump'])
 
       end
       it "create a new object when the id is provided" do

data/spec/integration/relation_delegation_spec.rb

@@ -38,27 +38,27 @@ describe ActiveFedora::Model do
     subject { ModelIntegrationSpec::Basic.where(bar: 'Peanuts') }
 
     it "should map" do
-      subject.map(&:id).should == [instance2.id, instance3.id]
+      expect(subject.map(&:id)).to eq([instance2.id, instance3.id])
     end
 
     it "should collect" do
-      subject.collect(&:id).should == [instance2.id, instance3.id]
+      expect(subject.collect(&:id)).to eq([instance2.id, instance3.id])
     end
 
     it "should have each" do
       t = double
-      t.should_receive(:foo).twice
+      expect(t).to receive(:foo).twice
       subject.each { t.foo }
     end
 
     it "should have all?" do
-      expect(subject.all? { |t| t.foo == ['Alpha']}).to be_false
-      expect(subject.all? { |t| t.bar == ['Peanuts']}).to be_true
+      expect(subject.all? { |t| t.foo == ['Alpha']}).to be_falsey
+      expect(subject.all? { |t| t.bar == ['Peanuts']}).to be_truthy
     end
 
     it "should have include?" do
-      expect(subject.include?(instance1)).to be_false
-      expect(subject.include?(instance2)).to be_true
+      expect(subject.include?(instance1)).to be_falsey
+      expect(subject.include?(instance2)).to be_truthy
     end
   end
 end

data/spec/integration/relation_spec.rb

@@ -14,7 +14,7 @@ describe ActiveFedora::Base do
   end
 
   subject { Library.all } 
-  its(:class) {should eq ActiveFedora::Relation }
+  its(:class) {is_expected.to eq ActiveFedora::Relation }
 
   before :all do
     Library.create
@@ -32,7 +32,7 @@ describe ActiveFedora::Base do
       expect(subject).to be_loaded
     end
     it "shouldn't reload" do
-      ActiveFedora::Relation.any_instance.should_not_receive :find_each
+      expect_any_instance_of(ActiveFedora::Relation).not_to receive :find_each
       subject[0]
     end
   end

data/spec/integration/rels_ext_datastream_spec.rb

@@ -60,7 +60,7 @@ describe ActiveFedora::RelsExtDatastream do
       rexml1 = REXML::Document.new(@test_datastream.to_rels_ext())
       @test_datastream.serialize!
       rexml2 = REXML::Document.new(@test_object.datastreams["RELS-EXT"].content)
-      rexml1.root.elements["rdf:Description"].inspect.should eql(rexml2.root.elements["rdf:Description"].inspect)
+      expect(rexml1.root.elements["rdf:Description"].inspect).to eql(rexml2.root.elements["rdf:Description"].inspect)
     end
   
   end
@@ -72,11 +72,11 @@ describe ActiveFedora::RelsExtDatastream do
     end
     @test_object.save
     # make sure that _something_ was actually added to the object's relationships hash
-    @test_object.ids_for_outbound(:is_member_of).size.should == 1
+    expect(@test_object.ids_for_outbound(:is_member_of).size).to eq(1)
     new_rels = ActiveFedora::Base.find(@test_object.pid).relationships
     # This stopped working, need to push an issue into the rdf library. (when dumping ntriples, the order of assertions changed)
     #new_rels.should == @test_object.relationships
-    new_rels.dump(:rdfxml).should == @test_object.relationships.dump(:rdfxml)
+    expect(new_rels.dump(:rdfxml)).to eq(@test_object.relationships.dump(:rdfxml))
   end
 
 end

data/spec/integration/scoped_query_spec.rb

@@ -39,18 +39,18 @@ describe "scoped queries" do
     describe ".all" do
       it "should return an array of instances of the calling Class" do
         result = ModelIntegrationSpec::Basic.all.to_a
-        result.should be_instance_of(Array)
+        expect(result).to be_instance_of(Array)
         # this test is meaningless if the array length is zero
-        result.length.should > 0
+        expect(result.length).to be > 0
         result.each do |obj|
-          obj.class.should == ModelIntegrationSpec::Basic
+          expect(obj.class).to eq(ModelIntegrationSpec::Basic)
         end
       end
     end
 
     describe ".first" do
       it "should return one instance of the calling class" do
-        ModelIntegrationSpec::Basic.first.should == test_instance
+        expect(ModelIntegrationSpec::Basic.first).to eq(test_instance)
       end
     end
   end
@@ -67,33 +67,33 @@ describe "scoped queries" do
         test_instance3.delete
       end
       it "should query" do
-        ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('foo', type: :string)=> 'Beta').should == [test_instance1]
-        ModelIntegrationSpec::Basic.where('foo' => 'Beta').should == [test_instance1]
+        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('foo', type: :string)=> 'Beta')).to eq([test_instance1])
+        expect(ModelIntegrationSpec::Basic.where('foo' => 'Beta')).to eq([test_instance1])
       end
       it "should order" do
-        ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').should == [test_instance2, test_instance1, test_instance3]
+        expect(ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc')).to eq([test_instance2, test_instance1, test_instance3])
       end
       it "should limit" do
-        ModelIntegrationSpec::Basic.limit(1).should == [test_instance1]
+        expect(ModelIntegrationSpec::Basic.limit(1)).to eq([test_instance1])
       end
       it "should offset" do
-        ModelIntegrationSpec::Basic.offset(1).should == [test_instance2, test_instance3]
+        expect(ModelIntegrationSpec::Basic.offset(1)).to eq([test_instance2, test_instance3])
       end
 
       it "should chain queries" do
-        ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').limit(1).should == [test_instance2]
+        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').limit(1)).to eq([test_instance2])
       end
 
       it "should wrap string conditions with parentheses" do
-        ModelIntegrationSpec::Basic.where("foo:bar OR bar:baz").where_values.should == ["(foo:bar OR bar:baz)"]
+        expect(ModelIntegrationSpec::Basic.where("foo:bar OR bar:baz").where_values).to eq(["(foo:bar OR bar:baz)"])
       end
 
       it "should chain where queries" do
-        ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').where("#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar").where_values.should == ["#{ActiveFedora::SolrService.solr_name('bar', type: :string)}:Peanuts", "(#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar)"]
+        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').where("#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar").where_values).to eq(["#{ActiveFedora::SolrService.solr_name('bar', type: :string)}:Peanuts", "(#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar)"])
       end
 
       it "should chain count" do
-        ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').count.should == 2 
+        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').count).to eq(2) 
       end
 
       it "calling first should not affect the relation's ability to get all results later" do
@@ -125,7 +125,7 @@ describe "scoped queries" do
       end
       it "should log an error" do
         expect(ActiveFedora::Base.logger).to receive(:error).with("Although #{pid} was found in Solr, it doesn't seem to exist in Fedora. The index is out of synch.")
-        ModelIntegrationSpec::Basic.all.should == [test_instance1, test_instance3]
+        expect(ModelIntegrationSpec::Basic.all).to eq([test_instance1, test_instance3])
       end
     end
   end

data/spec/integration/solr_service_spec.rb

@@ -39,9 +39,9 @@ describe ActiveFedora::SolrService do
       query = "id\:#{RSolr.solr_escape(@test_object.pid)} OR id\:#{RSolr.solr_escape(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result)
-      result.length.should == 2
+      expect(result.length).to eq(2)
       result.each do |r|
-        (r.class == ActiveFedora::Base || r.class == FooObject).should be_true
+        expect(r.class == ActiveFedora::Base || r.class == FooObject).to be_truthy
       end
     end
     
@@ -49,21 +49,21 @@ describe ActiveFedora::SolrService do
       query = "id\:#{RSolr.solr_escape(@test_object.pid)} OR id\:#{RSolr.solr_escape(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
-      result.length.should == 2
+      expect(result.length).to eq(2)
       result.each do |r|
-        r.inner_object.should be_a(ActiveFedora::SolrDigitalObject)
-        [ActiveFedora::Base, FooObject].should include(r.class)
-        ['test_object','foo_object'].should include(r.label)
-        @test_object.inner_object.profile.should == @profiles['test']
-        @foo_object.inner_object.profile.should == @profiles['foo']
-        @foo_object.datastreams['descMetadata'].profile.should == @profiles['foo_descMetadata']
-        @foo_object.datastreams['descMetadata'].content.should be_equivalent_to(@foo_content)
+        expect(r.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
+        expect([ActiveFedora::Base, FooObject]).to include(r.class)
+        expect(['test_object','foo_object']).to include(r.label)
+        expect(@test_object.inner_object.profile).to eq(@profiles['test'])
+        expect(@foo_object.inner_object.profile).to eq(@profiles['foo'])
+        expect(@foo_object.datastreams['descMetadata'].profile).to eq(@profiles['foo_descMetadata'])
+        expect(@foo_object.datastreams['descMetadata'].content).to be_equivalent_to(@foo_content)
       end
     end
     
     it 'should instantiate all datastreams in the solr doc, even ones undeclared by the class' do
       obj = ActiveFedora::Base.load_instance_from_solr @foo_object.pid 
-      obj.datastreams.keys.should include('descMetadata')
+      expect(obj.datastreams.keys).to include('descMetadata')
     end
     
     it 'should #reify a lightweight object as a new instance' do
@@ -72,10 +72,10 @@ describe ActiveFedora::SolrService do
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
       real_foo = solr_foo.reify
-      solr_foo.inner_object.should be_a(ActiveFedora::SolrDigitalObject)
-      real_foo.inner_object.should be_a(ActiveFedora::DigitalObject)
-      solr_foo.label.should == 'foo_object'
-      real_foo.label.should == 'foo_object'
+      expect(solr_foo.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
+      expect(real_foo.inner_object).to be_a(ActiveFedora::DigitalObject)
+      expect(solr_foo.label).to eq('foo_object')
+      expect(real_foo.label).to eq('foo_object')
     end
     
     it 'should #reify! a lightweight object within the same instance' do
@@ -83,10 +83,10 @@ describe ActiveFedora::SolrService do
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
-      solr_foo.inner_object.should be_a(ActiveFedora::SolrDigitalObject)
+      expect(solr_foo.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
       solr_foo.reify!
-      solr_foo.inner_object.should be_a(ActiveFedora::DigitalObject)
-      solr_foo.label.should == 'foo_object'
+      expect(solr_foo.inner_object).to be_a(ActiveFedora::DigitalObject)
+      expect(solr_foo.label).to eq('foo_object')
     end
     
     it 'should raise an exception when attempting to reify a first-class object' do
@@ -94,17 +94,17 @@ describe ActiveFedora::SolrService do
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
-      lambda {solr_foo.reify}.should_not raise_exception
-      lambda {solr_foo.reify!}.should_not raise_exception
-      lambda {solr_foo.reify!}.should raise_exception(/already a full/)
-      lambda {solr_foo.reify}.should raise_exception(/already a full/)
+      expect {solr_foo.reify}.not_to raise_exception
+      expect {solr_foo.reify!}.not_to raise_exception
+      expect {solr_foo.reify!}.to raise_exception(/already a full/)
+      expect {solr_foo.reify}.to raise_exception(/already a full/)
     end
   
     it 'should call load_instance_from_solr if :load_from_solr option passed in' do
       query = "id\:#{RSolr.solr_escape(@test_object.pid)} OR id\:#{RSolr.solr_escape(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      ActiveFedora::Base.should_receive(:load_instance_from_solr).once
-      FooObject.should_receive(:load_instance_from_solr).once
+      expect(ActiveFedora::Base).to receive(:load_instance_from_solr).once
+      expect(FooObject).to receive(:load_instance_from_solr).once
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
     end
     

data/spec/support/mock_fedora.rb

@@ -2,34 +2,34 @@ def mock_client
   return @mock_client if @mock_client
   @mock_client = double("client")
   @getter = double("getter")
-  @getter.stub(:get).and_return('')
-  @mock_client.stub(:[]).with("describe?xml=true").and_return('')
+  allow(@getter).to receive(:get).and_return('')
+  allow(@mock_client).to receive(:[]).with("describe?xml=true").and_return('')
   @mock_client 
 end
   
 def stub_get(pid, datastreams=nil, record_exists=false)
   pid.gsub!(/:/, '%3A')
   if record_exists
-    mock_client.stub(:[]).with("objects/#{pid}?format=xml").and_return(double('get getter', :get=>'foobar'))
+    allow(mock_client).to receive(:[]).with("objects/#{pid}?format=xml").and_return(double('get getter', :get=>'foobar'))
   else
-    mock_client.stub(:[]).with("objects/#{pid}?format=xml").and_raise(RestClient::ResourceNotFound)
+    allow(mock_client).to receive(:[]).with("objects/#{pid}?format=xml").and_raise(RestClient::ResourceNotFound)
   end
-  mock_client.stub(:[]).with("objects/#{pid}/datastreams?format=xml").and_return(@getter)
+  allow(mock_client).to receive(:[]).with("objects/#{pid}/datastreams?format=xml").and_return(@getter)
   datastreams ||= ['someData', 'withText', 'withText2', 'RELS-EXT']
   datastreams.each do |dsid|
-    mock_client.stub(:[]).with("objects/#{pid}/datastreams/#{dsid}?format=xml").and_return(@getter)
+    allow(mock_client).to receive(:[]).with("objects/#{pid}/datastreams/#{dsid}?format=xml").and_return(@getter)
   end
 end
 
 def stub_ingest(pid=nil)
   n = pid ? pid.gsub(/:/, '%3A') : nil
-  mock_client.should_receive(:[]).with("objects/#{n || 'new'}").and_return(double("ingester", :post=>pid))
+  expect(mock_client).to receive(:[]).with("objects/#{n || 'new'}").and_return(double("ingester", :post=>pid))
 end
 
 def stub_add_ds(pid, dsids)
   pid.gsub!(/:/, '%3A')
   dsids.each do |dsid|
-    client = mock_client.stub(:[]).with do |params|
+    client = allow(mock_client).to receive(:[]) do |params|
       /objects\/#{pid}\/datastreams\/#{dsid}/.match(params)
     end
     client.and_return(double("ds_adder", :post=>pid, :get=>''))
@@ -39,7 +39,6 @@ end
 def stub_get_content(pid, dsids)
   pid.gsub!(/:/, '%3A')
   dsids.each do |dsid|
-    mock_client.stub(:[]).with { |params| /objects\/#{pid}\/datastreams\/#{dsid}\/content/.match(params)}.and_return(double("content_accessor", :post=>pid, :get=>''))
+    allow(mock_client).to receive(:[]) { |params| /objects\/#{pid}\/datastreams\/#{dsid}\/content/.match(params)}.and_return(double("content_accessor", :post=>pid, :get=>''))
   end
 end
-

data/spec/unit/active_fedora_spec.rb

@@ -14,36 +14,36 @@ describe ActiveFedora do
   describe "initialization methods" do
     describe "environment" do
       it "should use config_options[:environment] if set" do
-        ActiveFedora.stub(:config_options => {:environment=>"ballyhoo"})
-        ActiveFedora.environment.should eql("ballyhoo")
+        allow(ActiveFedora).to receive_messages(:config_options => {:environment=>"ballyhoo"})
+        expect(ActiveFedora.environment).to eql("ballyhoo")
       end
 
       it "should use Rails.env if no config_options and Rails.env is set" do
         stub_rails(:env => "bedbugs")
-        ActiveFedora.stub(:config_options => {})
-        ActiveFedora.environment.should eql("bedbugs")
+        allow(ActiveFedora).to receive_messages(:config_options => {})
+        expect(ActiveFedora.environment).to eql("bedbugs")
         unstub_rails
       end
 
       it "should use ENV['environment'] if neither config_options nor Rails.env are set" do
         ENV['environment'] = "wichita"
-        ActiveFedora.stub(:config_options => {})
-        ActiveFedora.environment.should eql("wichita")
+        allow(ActiveFedora).to receive_messages(:config_options => {})
+        expect(ActiveFedora.environment).to eql("wichita")
         ENV['environment']='test'
       end
 
       it "should use ENV['RAILS_ENV'] and log a warning if none of the above are set" do
         ENV['environment']=nil
         ENV['RAILS_ENV'] = "rails_env"
-        lambda {ActiveFedora.environment}.should raise_error(RuntimeError, "You're depending on RAILS_ENV for setting your environment. Please use ENV['environment'] for non-rails environment setting: 'rake foo:bar environment=test'")
+        expect {ActiveFedora.environment}.to raise_error(RuntimeError, "You're depending on RAILS_ENV for setting your environment. Please use ENV['environment'] for non-rails environment setting: 'rake foo:bar environment=test'")
         ENV['environment']='test'
       end
 
       it "should be development if none of the above are present" do
         ENV['environment']=nil
         ENV['RAILS_ENV'] = nil
-        ActiveFedora.stub(:config_options => {})
-        ActiveFedora.environment.should == 'development'
+        allow(ActiveFedora).to receive_messages(:config_options => {})
+        expect(ActiveFedora.environment).to eq('development')
         ENV['environment']="test"
       end
     end
@@ -59,7 +59,7 @@ describe ActiveFedora do
     describe "outside of rails" do
        it "should load the passed config if explicit config passed in as a string" do
         ActiveFedora.init(:fedora_config_path=>'./spec/fixtures/rails_root/config/fedora.yml', :environment => 'test')
-        ActiveFedora.config.credentials.should == {:url=> "http://testhost.com:8983/fedora", :user=>'fedoraAdmin', :password=>'fedoraAdmin'}
+        expect(ActiveFedora.config.credentials).to eq({:url=> "http://testhost.com:8983/fedora", :user=>'fedoraAdmin', :password=>'fedoraAdmin'})
       end
     end
 
@@ -79,22 +79,22 @@ describe ActiveFedora do
             solr_config_path = File.expand_path(File.join(File.dirname(__FILE__),"../fixtures/rails_root/config/solr.yml"))
             pred_config_path = File.expand_path(File.join(File.dirname(__FILE__),"../fixtures/rails_root/config/predicate_mappings.yml"))
             
-            File.stub(:open).with(fedora_config_path).and_return(fedora_config)
-            File.stub(:open).with(solr_config_path).and_return(solr_config)
-            ActiveFedora::SolrService.stub(:load_mappings) #For the solrizer solr_mappings.yml
+            allow(File).to receive(:open).with(fedora_config_path).and_return(fedora_config)
+            allow(File).to receive(:open).with(solr_config_path).and_return(solr_config)
+            allow(ActiveFedora::SolrService).to receive(:load_mappings) #For the solrizer solr_mappings.yml
 
             ActiveFedora.init(:fedora_config_path=>fedora_config_path,:solr_config_path=>solr_config_path)
-            ActiveFedora.solr.class.should == ActiveFedora::SolrService
+            expect(ActiveFedora.solr.class).to eq(ActiveFedora::SolrService)
           end
         end
 
         describe "with no explicit config path" do
           it "should look for the file in the path defined at Rails.root" do
-            ActiveFedora::SolrService.stub(:load_mappings) #necessary or else it will load the solrizer config and it breaks other tests in the suite.
+            allow(ActiveFedora::SolrService).to receive(:load_mappings) #necessary or else it will load the solrizer config and it breaks other tests in the suite.
             
             stub_rails(:root=>File.join(File.dirname(__FILE__),"../fixtures/rails_root"))
             ActiveFedora.init()
-            ActiveFedora.config.credentials[:url].should == "http://testhost.com:8983/fedora"
+            expect(ActiveFedora.config.credentials[:url]).to eq("http://testhost.com:8983/fedora")
           end
         end
       end
@@ -111,13 +111,13 @@ describe ActiveFedora do
       end
     end
     it "should return class constants based on strings" do
-      ActiveFedora.class_from_string("Om").should == Om
-      ActiveFedora.class_from_string("ActiveFedora::RDF::Indexing").should == ActiveFedora::RDF::Indexing
-      ActiveFedora.class_from_string("Indexing", ActiveFedora::RDF).should == ActiveFedora::RDF::Indexing
+      expect(ActiveFedora.class_from_string("Om")).to eq(Om)
+      expect(ActiveFedora.class_from_string("ActiveFedora::RDF::Indexing")).to eq(ActiveFedora::RDF::Indexing)
+      expect(ActiveFedora.class_from_string("Indexing", ActiveFedora::RDF)).to eq(ActiveFedora::RDF::Indexing)
     end
 
     it "should find sibling classes" do
-      ActiveFedora.class_from_string("SiblingClass", ParentClass::OtherSiblingClass).should == ParentClass::SiblingClass
+      expect(ActiveFedora.class_from_string("SiblingClass", ParentClass::OtherSiblingClass)).to eq(ParentClass::SiblingClass)
     end
 
     it "should raise a NameError if the class isn't found" do