active-fedora 8.2.1 → 8.2.2

data/spec/unit/rspec_matchers/have_many_associated_active_fedora_objects_matcher_spec.rb

@@ -11,17 +11,17 @@ describe RSpec::Matchers, "have_many_associated_active_fedora_objects_matcher" d
   let(:association) { :association }
 
   it 'should match when association is properly stored in fedora' do
-    subject.class.should_receive(:find).with(pid).and_return(subject)
-    subject.should_receive(association).and_return([object1,object2])
-    subject.should have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
+    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject).to receive(association).and_return([object1,object2])
+    expect(subject).to have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
   end
 
   it 'should not match when association is different' do
-    subject.class.should_receive(:find).with(pid).and_return(subject)
-    subject.should_receive(association).and_return([object1,object3])
-    lambda {
-      subject.should have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
-    }.should (
+    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject).to receive(association).and_return([object1,object3])
+    expect {
+      expect(subject).to have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
+    }.to (
       raise_error(
         RSpec::Expectations::ExpectationNotMetError,
         /expected #{subject.class} PID=#{pid} association: #{association.inspect}/
@@ -30,9 +30,9 @@ describe RSpec::Matchers, "have_many_associated_active_fedora_objects_matcher" d
   end
 
   it 'should require :with_objects option' do
-    lambda {
-      subject.should have_many_associated_active_fedora_objects(association)
-    }.should(
+    expect {
+      expect(subject).to have_many_associated_active_fedora_objects(association)
+    }.to(
       raise_error(
         ArgumentError,
         "subject.should have_many_associated_active_fedora_objects(<association_name>).with_objects(<objects[]>)"

data/spec/unit/rspec_matchers/have_predicate_matcher_spec.rb

@@ -11,17 +11,17 @@ describe RSpec::Matchers, "have_predicate_matcher" do
   let(:predicate) { :predicate }
 
   it 'should match when relationship is "what we have in Fedora"' do
-    subject.class.should_receive(:find).with(pid).and_return(subject)
-    subject.should_receive(:relationships).with(predicate).and_return([object1,object2])
-    subject.should have_predicate(predicate).with_objects([object1, object2])
+    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject).to receive(:relationships).with(predicate).and_return([object1,object2])
+    expect(subject).to have_predicate(predicate).with_objects([object1, object2])
   end
 
   it 'should not match when relationship is different' do
-    subject.class.should_receive(:find).with(pid).and_return(subject)
-    subject.should_receive(:relationships).with(predicate).and_return([object1,object3])
-    lambda {
-      subject.should have_predicate(predicate).with_objects([object1, object2])
-    }.should (
+    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject).to receive(:relationships).with(predicate).and_return([object1,object3])
+    expect {
+      expect(subject).to have_predicate(predicate).with_objects([object1, object2])
+    }.to (
       raise_error(
         RSpec::Expectations::ExpectationNotMetError,
         /expected #{subject.class} PID=#{pid} relationship: #{predicate.inspect}/
@@ -30,9 +30,9 @@ describe RSpec::Matchers, "have_predicate_matcher" do
   end
 
   it 'should require :with_objects option' do
-    lambda {
-      subject.should have_predicate(predicate)
-    }.should(
+    expect {
+      expect(subject).to have_predicate(predicate)
+    }.to(
       raise_error(
         ArgumentError,
         "subject.should have_predicate(<predicate>).with_objects(<objects[]>)"

data/spec/unit/rspec_matchers/match_fedora_datastream_matcher_spec.rb

@@ -15,14 +15,14 @@ describe RSpec::Matchers, "match_fedora_datastream" do
 
   it 'should match based on request' do
     stub_request(:get, datastream_url).to_return(:body => expected_xml, :status => 200)
-    subject.should match_fedora_datastream(datastream_name).with(expected_xml)
+    expect(subject).to match_fedora_datastream(datastream_name).with(expected_xml)
   end
 
   it 'should handle non-matching requests' do
     stub_request(:get, datastream_url).to_return(:body => "<parent>#{expected_xml}</parent>", :status => 200)
-    lambda {
-      subject.should match_fedora_datastream(datastream_name).with(expected_xml)
-    }.should(
+    expect {
+      expect(subject).to match_fedora_datastream(datastream_name).with(expected_xml)
+    }.to(
       raise_error(
         RSpec::Expectations::ExpectationNotMetError,
         /expected #{subject.class} PID=#{pid} datastream: #{datastream_name.inspect} to match Fedora/
@@ -32,9 +32,9 @@ describe RSpec::Matchers, "match_fedora_datastream" do
 
   it 'should require :with option' do
     stub_request(:get, datastream_url).to_return(:body => "<parent>#{expected_xml}</parent>", :status => 200)
-    lambda {
-      subject.should match_fedora_datastream(datastream_name)
-    }.should(
+    expect {
+      expect(subject).to match_fedora_datastream(datastream_name)
+    }.to(
       raise_error(
         ArgumentError,
         "match_fedora_datastream(<datastream_name>).with(<expected_xml>)"

data/spec/unit/rubydora_connection_spec.rb

@@ -5,9 +5,9 @@ describe ActiveFedora::RubydoraConnection do
   describe 'initialize' do
     it "should pass through valid options" do
       @instance = ActiveFedora::RubydoraConnection.new :timeout => 3600, :fake_option => :missing, :force => true, :validateChecksum=>true
-      @instance.connection.client.options[:timeout].should == 3600
-      @instance.connection.config[:validateChecksum].should == true
-      @instance.connection.client.options.has_key?(:fake_option).should be_false
+      expect(@instance.connection.client.options[:timeout]).to eq(3600)
+      expect(@instance.connection.config[:validateChecksum]).to eq(true)
+      expect(@instance.connection.client.options.has_key?(:fake_option)).to be_falsey
     end
   end
 end

data/spec/unit/semantic_node_spec.rb

@@ -22,7 +22,7 @@ describe ActiveFedora::SemanticNode do
       end
 
       @node = SpecNode.new
-      @node.stub(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
+      allow(@node).to receive(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
       @node.pid = increment_pid
     end
     
@@ -32,37 +32,37 @@ describe ActiveFedora::SemanticNode do
 
     describe "pid_from_uri" do
       it "should strip the info:fedora/ out of a given string" do 
-        SpecNode.pid_from_uri("info:fedora/FOO:BAR").should == "FOO:BAR"
+        expect(SpecNode.pid_from_uri("info:fedora/FOO:BAR")).to eq("FOO:BAR")
       end
     end
     
     describe ".add_relationship" do
       it "should add relationship to the relationships graph" do
         @node.add_relationship("isMemberOf", 'demo:9')
-        @node.ids_for_outbound("isMemberOf").should == ['demo:9']
+        expect(@node.ids_for_outbound("isMemberOf")).to eq(['demo:9'])
       end
       it "should not be written into the graph until it is saved" do
         @n1 = ActiveFedora::Base.new
         @node.add_relationship(:has_part, @n1)
-        @node.relationships.statements.to_a.first.object.to_s.should == 'info:fedora/' 
+        expect(@node.relationships.statements.to_a.first.object.to_s).to eq('info:fedora/') 
         @n1.save
-        @node.relationships.statements.to_a.first.object.to_s.should == @n1.internal_uri
+        expect(@node.relationships.statements.to_a.first.object.to_s).to eq(@n1.internal_uri)
       end
 
       it "should add a literal relationship to the relationships graph" do
         @node.add_relationship("isMemberOf", 'demo:9', true)
-        @node.relationships("isMemberOf").should == ['demo:9']
+        expect(@node.relationships("isMemberOf")).to eq(['demo:9'])
       end
       
       it "adding relationship to an instance should not affect class-level relationships hash" do 
         local_test_node1 = SpecNode.new
         local_test_node2 = SpecNode.new
-        local_test_node1.stub(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
+        allow(local_test_node1).to receive(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
         local_test_node1.add_relationship(:is_member_of, 'demo:10')
-        local_test_node2.stub(:rels_ext).and_return(double('rels-ext', :content=>''))
+        allow(local_test_node2).to receive(:rels_ext).and_return(double('rels-ext', :content=>''))
         
-        local_test_node1.relationships(:is_member_of).should == ["demo:10"]
-        local_test_node2.relationships(:is_member_of).should == []
+        expect(local_test_node1.relationships(:is_member_of)).to eq(["demo:10"])
+        expect(local_test_node2.relationships(:is_member_of)).to eq([])
       end
       
     end
@@ -75,28 +75,28 @@ describe ActiveFedora::SemanticNode do
       end
       it "should clear the specified relationship" do
         @node.clear_relationship(:is_member_of)
-        @node.relationships(:is_member_of).should == []
-        @node.relationships(:has_description).should == ['demo:9']
+        expect(@node.relationships(:is_member_of)).to eq([])
+        expect(@node.relationships(:has_description)).to eq(['demo:9'])
       end
     end
     
     describe '#remove_relationship' do
       it 'should remove a relationship from the relationships hash' do
-        @node.stub(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
+        allow(@node).to receive(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
         @node.add_relationship(:has_part, "info:fedora/3")
         @node.add_relationship(:has_part, "info:fedora/4")
         #check both are there
-        @node.ids_for_outbound(:has_part).should include "3", "4"
+        expect(@node.ids_for_outbound(:has_part)).to include "3", "4"
         @node.remove_relationship(:has_part, "info:fedora/3")
         #check returns false if relationship does not exist and does nothing with different predicate
         @node.remove_relationship(:has_member,"info:fedora/4")
         #check only one item removed
-        @node.ids_for_outbound(:has_part).should == ['4']
+        expect(@node.ids_for_outbound(:has_part)).to eq(['4'])
         @node.remove_relationship(:has_part,"info:fedora/4")
         #check last item removed and predicate removed since now emtpy
-        @node.ids_for_outbound(:has_part).should == []
+        expect(@node.ids_for_outbound(:has_part)).to eq([])
 
-        @node.relationships_are_dirty.should == true
+        expect(@node.relationships_are_dirty).to eq(true)
         
       end
     end

data/spec/unit/serializers_spec.rb

@@ -14,7 +14,7 @@ describe ActiveFedora::Attributes::Serializers do
     subject { Foo.new }
     it "should deserialize dates" do
       subject.attributes = {'birthday(1i)' =>'2012', 'birthday(2i)' =>'10', 'birthday(3i)' => '31'}
-      subject.birthday.should == '2012-10-31'
+      expect(subject.birthday).to eq('2012-10-31')
     end
   end
 

data/spec/unit/service_definitions_spec.rb

@@ -14,50 +14,50 @@ describe ActiveFedora::ServiceDefinitions do
 </fmm:MethodMap>
     MMAP
     @repository = ActiveFedora::Base.connection_for_pid(0)
-    @repository.stub(:datastream_dissemination).with({:pid=>'test:12',:dsid=>'METHODMAP'}).and_return mmap
+    allow(@repository).to receive(:datastream_dissemination).with({:pid=>'test:12',:dsid=>'METHODMAP'}).and_return mmap
     Test.has_service_definition "test:12"
   end
 
   subject { 
       obj = Test.new()
-      obj.stub(:pid).and_return('monkey:99')
+      allow(obj).to receive(:pid).and_return('monkey:99')
       obj
     }
   describe "method lookup" do
     it "should find method keys in the YAML config" do
-      ActiveFedora::ServiceDefinitions.lookup_method("fedora-system:3", "viewObjectProfile").should == :object_profile
+      expect(ActiveFedora::ServiceDefinitions.lookup_method("fedora-system:3", "viewObjectProfile")).to eq(:object_profile)
     end
   end
   describe "method creation" do
     it "should create the system sdef methods" do
-      subject.should respond_to(:object_profile)
+      expect(subject).to respond_to(:object_profile)
     end
     it "should create the declared sdef methods" do
-      subject.should respond_to(:document_style_1)
+      expect(subject).to respond_to(:document_style_1)
     end
   end
   describe "generated method" do
     it "should call the appropriate rubydora rest api method" do
-      @repository.should_receive(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1'})
+      expect(@repository).to receive(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1'})
       #@mock_client.stub(:[]).with('objects/monkey%3A99/methods/test%3A12/getDocumentStyle1')
 
       subject.document_style_1
     end
     it "should call the appropriate rubydora rest api method with parameters" do
-      @repository.should_receive(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1', :format=>'xml'})
+      expect(@repository).to receive(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1', :format=>'xml'})
       obj = Test.new()
-      obj.stub(:pid).and_return('monkey:99')
+      allow(obj).to receive(:pid).and_return('monkey:99')
       obj.document_style_1({:format=>'xml'})
     end
     it "should call the appropriate rubydora rest api method with a block" do
-      @repository.stub(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1'}).and_yield "ping!","pang!"
+      allow(@repository).to receive(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1'}).and_yield "ping!","pang!"
       obj = Test.new()
-      obj.stub(:pid).and_return('monkey:99')
+      allow(obj).to receive(:pid).and_return('monkey:99')
       block_response = ""
       obj.document_style_1 {|res,req|
         block_response += 'pong!' if res == "ping!" and req == "pang!"
       }
-      block_response.should == "pong!"
+      expect(block_response).to eq("pong!")
     end
   end
 end

data/spec/unit/simple_datastream_spec.rb

@@ -12,7 +12,7 @@ describe ActiveFedora::SimpleDatastream do
 
   end
   it "from_xml should parse everything correctly" do
-    @test_ds.ng_xml.should be_equivalent_to @sample_xml
+    expect(@test_ds.ng_xml).to be_equivalent_to @sample_xml
   end
 
   
@@ -23,14 +23,14 @@ describe ActiveFedora::SimpleDatastream do
         it "should respond to getters and setters for the string typed #{el} element" do
           value = "Hey #{el}"
           @test_ds.send("#{el.to_s}=", value) 
-          @test_ds.send(el).first.should == value  #Looking at first because creator has 2 nodes
+          expect(@test_ds.send(el).first).to eq(value)  #Looking at first because creator has 2 nodes
         end
       end
 
       it "should set date elements" do
         d = Date.parse('1939-05-23')
         @test_ds.creation_date = d
-        @test_ds.creation_date.first.should == d
+        expect(@test_ds.creation_date.first).to eq(d)
       end
     end
   end
@@ -40,7 +40,7 @@ describe ActiveFedora::SimpleDatastream do
       @test_ds.publisher= "charlie"
       @test_ds.coverage= ["80%", "20%"]
 
-      @test_ds.to_xml.should be_equivalent_to('
+      expect(@test_ds.to_xml).to be_equivalent_to('
         <fields>
           <coverage>80%</coverage>
           <coverage>20%</coverage>
@@ -54,8 +54,8 @@ describe ActiveFedora::SimpleDatastream do
   describe "#to_solr" do
     it "should have title" do
       solr = @test_ds.to_solr
-      solr[ActiveFedora::SolrService.solr_name('publisher', type: :string)].should == "publisher1"
-      solr[ActiveFedora::SolrService.solr_name('creation_date', type: :date)].should == "2012-01-15"
+      expect(solr[ActiveFedora::SolrService.solr_name('publisher', type: :string)]).to eq("publisher1")
+      expect(solr[ActiveFedora::SolrService.solr_name('creation_date', type: :date)]).to eq("2012-01-15")
     end
   end
 

data/spec/unit/solr_config_options_spec.rb

@@ -24,17 +24,17 @@ describe ActiveFedora do
       SOLR_DOCUMENT_ID = "id"
     end
     it "should be used by ActiveFedora::Base.to_solr" do
-      @test_object.stub(pid: 'changeme:123')
+      allow(@test_object).to receive_messages(pid: 'changeme:123')
       SOLR_DOCUMENT_ID = "MY_SAMPLE_ID"
-      @test_object.to_solr[SOLR_DOCUMENT_ID.to_sym].should == 'changeme:123'
-      @test_object.to_solr[:id].should be_nil
+      expect(@test_object.to_solr[SOLR_DOCUMENT_ID.to_sym]).to eq('changeme:123')
+      expect(@test_object.to_solr[:id]).to be_nil
     end
 
     it "should be used by ActiveFedora::Base#find_with_conditions" do
       mock_response = double("SolrResponse")
-      ActiveFedora::SolrService.should_receive(:query).with("_query_:\"{!raw f=#{ActiveFedora::SolrService.solr_name("has_model", :symbol)}}info:fedora/afmodel:SolrSpecModel_Basic\" AND " + SOLR_DOCUMENT_ID + ':changeme\\:30', {:sort => ["#{ActiveFedora::SolrService.solr_name("system_create", :stored_sortable, type: :date)} asc"]}).and_return(mock_response)
+      expect(ActiveFedora::SolrService).to receive(:query).with("_query_:\"{!raw f=#{ActiveFedora::SolrService.solr_name("has_model", :symbol)}}info:fedora/afmodel:SolrSpecModel_Basic\" AND " + SOLR_DOCUMENT_ID + ':changeme\\:30', {:sort => ["#{ActiveFedora::SolrService.solr_name("system_create", :stored_sortable, type: :date)} asc"]}).and_return(mock_response)
   
-      SolrSpecModel::Basic.find_with_conditions(:id=>"changeme:30").should equal(mock_response)
+      expect(SolrSpecModel::Basic.find_with_conditions(:id=>"changeme:30")).to equal(mock_response)
     end
   end
   
@@ -50,14 +50,14 @@ describe ActiveFedora do
     it "should prevent Base.save from calling update_index if false" do
       dirty_ds = ActiveFedora::SimpleDatastream.new(@test_object.inner_object, 'ds1')
       @test_object.datastreams['ds1'] = dirty_ds
-      @test_object.stub(:datastreams).and_return({:ds1 => dirty_ds})
-      @test_object.should_receive(:update_index).never
-      @test_object.should_receive(:refresh)
+      allow(@test_object).to receive(:datastreams).and_return({:ds1 => dirty_ds})
+      expect(@test_object).to receive(:update_index).never
+      expect(@test_object).to receive(:refresh)
       @test_object.save
     end
     it "should prevent Base.delete from deleting the corresponding Solr document if false" do
-      ActiveFedora::SolrService.instance.conn.should_receive(:delete).with(@test_object.pid).never 
-      @test_object.inner_object.should_receive(:delete)
+      expect(ActiveFedora::SolrService.instance.conn).to receive(:delete).with(@test_object.pid).never 
+      expect(@test_object.inner_object).to receive(:delete)
       @test_object.delete
     end
   end

data/spec/unit/solr_digital_object_spec.rb

@@ -5,7 +5,7 @@ describe ActiveFedora::SolrDigitalObject do
     subject { ActiveFedora::SolrDigitalObject.new({},{'datastreams'=>{}}) }
     describe "when not finished" do
       it "should not respond_to? :repository" do
-        subject.should_not respond_to :repository
+        expect(subject).not_to respond_to :repository
       end
     end
     describe "when finished" do
@@ -13,7 +13,7 @@ describe ActiveFedora::SolrDigitalObject do
         subject.freeze
       end
       it "should respond_to? :repository" do
-        subject.should respond_to :repository
+        expect(subject).to respond_to :repository
       end
     end
   end
@@ -71,10 +71,10 @@ describe ActiveFedora::SolrDigitalObject do
       end
       subject { ActiveFedora::SolrDigitalObject.new({}, {'datastreams'=>{'properties'=>{'dsMIME'=>'text/xml'}}},WithoutMetadataDs) }
       it "should create an xml datastream" do
-        subject.datastreams['properties'].should be_kind_of ActiveFedora::OmDatastream
+        expect(subject.datastreams['properties']).to be_kind_of ActiveFedora::OmDatastream
       end
 
-      its(:new_record?) { should be_false }
+      its(:new_record?) { should be_falsey }
     end
     
     describe "with a ds spec that's not part of the solrized object" do

data/spec/unit/solr_service_spec.rb

@@ -10,28 +10,28 @@ describe ActiveFedora::SolrService do
   end
   
   it "should take a narg constructor and configure for localhost" do
-    RSolr.should_receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr')
+    expect(RSolr).to receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr')
     ActiveFedora::SolrService.register
   end
   it "should accept host arg into constructor" do
-    RSolr.should_receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://fubar')
+    expect(RSolr).to receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://fubar')
     ActiveFedora::SolrService.register('http://fubar')
   end
   it "should clobber options" do
-    RSolr.should_receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr', :autocommit=>:off, :foo=>:bar)
+    expect(RSolr).to receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr', :autocommit=>:off, :foo=>:bar)
     ActiveFedora::SolrService.register(nil, {:autocommit=>:off, :foo=>:bar})
   end
 
   it "should set the threadlocal solr service" do
-    RSolr.should_receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr', :autocommit=>:off, :foo=>:bar)
+    expect(RSolr).to receive(:connect).with(:read_timeout => 120, :open_timeout => 120, :url => 'http://localhost:8080/solr', :autocommit=>:off, :foo=>:bar)
     ss = ActiveFedora::SolrService.register(nil, {:autocommit=>:off, :foo=>:bar})
-    Thread.current[:solr_service].should == ss
-    ActiveFedora::SolrService.instance.should == ss
+    expect(Thread.current[:solr_service]).to eq(ss)
+    expect(ActiveFedora::SolrService.instance).to eq(ss)
   end
   it "should try to initialize if the service not initialized, and fail if it does not succeed" do
-    Thread.current[:solr_service].should be_nil
-    ActiveFedora::SolrService.should_receive(:register)
-    proc{ActiveFedora::SolrService.instance}.should raise_error(ActiveFedora::SolrNotInitialized)
+    expect(Thread.current[:solr_service]).to be_nil
+    expect(ActiveFedora::SolrService).to receive(:register)
+    expect{ActiveFedora::SolrService.instance}.to raise_error(ActiveFedora::SolrNotInitialized)
   end
 
   describe "reify solr results" do
@@ -51,42 +51,42 @@ describe ActiveFedora::SolrService do
     end
     describe ".reify_solr_result" do
       it "should use .find to instantiate objects" do
-        AudioRecord.should_receive(:find).with("my:_PID1_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_PID1_", cast: true)
         ActiveFedora::SolrService.reify_solr_result(@sample_solr_hits.first)
       end
       it "should use .load_instance_from_solr when called with :load_from_solr option" do
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits.first)
-        ActiveFedora::SolrService.should_not_receive(:query)
+        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits.first)
+        expect(ActiveFedora::SolrService).not_to receive(:query)
         ActiveFedora::SolrService.reify_solr_result(@sample_solr_hits.first, load_from_solr: true)
       end
     end
     describe ".reify_solr_results" do
       it "should use AudioRecord.find to instantiate objects" do
-        AudioRecord.should_receive(:find).with("my:_PID1_", cast: true)
-        AudioRecord.should_receive(:find).with("my:_PID2_", cast: true)
-        AudioRecord.should_receive(:find).with("my:_PID3_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_PID1_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_PID2_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_PID3_", cast: true)
         ActiveFedora::SolrService.reify_solr_results(@sample_solr_hits)
       end
       it "should use AudioRecord.load_instance_from_solr when called with :load_from_solr option" do
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits[0])
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID2_", @sample_solr_hits[1])
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID3_", @sample_solr_hits[2])
-        ActiveFedora::SolrService.should_not_receive(:query)
+        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits[0])
+        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID2_", @sample_solr_hits[1])
+        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID3_", @sample_solr_hits[2])
+        expect(ActiveFedora::SolrService).not_to receive(:query)
         ActiveFedora::SolrService.reify_solr_results(@sample_solr_hits, load_from_solr: true)
       end
     end
     describe ".lazy_reify_solr_results" do
       it "should lazily reify solr results" do
-        AudioRecord.should_receive(:find).with("my:_PID1_", cast: true)
-        AudioRecord.should_receive(:find).with("my:_PID2_", cast: true)
-        AudioRecord.should_receive(:find).with("my:_PID3_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_PID1_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_PID2_", cast: true)
+        expect(AudioRecord).to receive(:find).with("my:_PID3_", cast: true)
         ActiveFedora::SolrService.lazy_reify_solr_results(@sample_solr_hits).each {|r| r}
       end
       it "should use AudioRecord.load_instance_from_solr when called with :load_from_solr option" do
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits[0])
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID2_", @sample_solr_hits[1])
-        AudioRecord.should_receive(:load_instance_from_solr).with("my:_PID3_", @sample_solr_hits[2])
-        ActiveFedora::SolrService.should_not_receive(:query)
+        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID1_", @sample_solr_hits[0])
+        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID2_", @sample_solr_hits[1])
+        expect(AudioRecord).to receive(:load_instance_from_solr).with("my:_PID3_", @sample_solr_hits[2])
+        expect(ActiveFedora::SolrService).not_to receive(:query)
         ActiveFedora::SolrService.lazy_reify_solr_results(@sample_solr_hits, load_from_solr: true).each {|r| r}
       end
     end
@@ -100,11 +100,11 @@ describe ActiveFedora::SolrService do
   
   describe '#construct_query_for_pids' do
     it "should generate a useable solr query from an array of Fedora pids" do
-      ActiveFedora::SolrService.construct_query_for_pids(["my:_PID1_", "my:_PID2_", "my:_PID3_"]).should == '_query_:"{!raw f=id}my:_PID1_" OR _query_:"{!raw f=id}my:_PID2_" OR _query_:"{!raw f=id}my:_PID3_"'
+      expect(ActiveFedora::SolrService.construct_query_for_pids(["my:_PID1_", "my:_PID2_", "my:_PID3_"])).to eq('_query_:"{!raw f=id}my:_PID1_" OR _query_:"{!raw f=id}my:_PID2_" OR _query_:"{!raw f=id}my:_PID3_"')
 
     end
     it "should return a valid solr query even if given an empty array as input" do
-      ActiveFedora::SolrService.construct_query_for_pids([""]).should == "id:NEVER_USE_THIS_ID"
+      expect(ActiveFedora::SolrService.construct_query_for_pids([""])).to eq("id:NEVER_USE_THIS_ID")
       
     end
   end
@@ -113,33 +113,33 @@ describe ActiveFedora::SolrService do
     it "should call solr" do 
       mock_conn = double("Connection")
       stub_result = double("Result")
-      mock_conn.should_receive(:get).with('select', :params=>{:q=>'querytext', :qt=>'standard'}).and_return(stub_result)
-      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
-      ActiveFedora::SolrService.query('querytext', :raw=>true).should == stub_result
+      expect(mock_conn).to receive(:get).with('select', :params=>{:q=>'querytext', :qt=>'standard'}).and_return(stub_result)
+      allow(ActiveFedora::SolrService).to receive_messages(:instance =>double("instance", :conn=>mock_conn))
+      expect(ActiveFedora::SolrService.query('querytext', :raw=>true)).to eq(stub_result)
     end
   end
   describe ".count" do
     it "should return a count of matching records" do 
       mock_conn = double("Connection")
       stub_result = {'response' => {'numFound'=>'7'}}
-      mock_conn.should_receive(:get).with('select', :params=>{:rows=>0, :q=>'querytext', :qt=>'standard'}).and_return(stub_result)
-      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
-      ActiveFedora::SolrService.count('querytext').should == 7 
+      expect(mock_conn).to receive(:get).with('select', :params=>{:rows=>0, :q=>'querytext', :qt=>'standard'}).and_return(stub_result)
+      allow(ActiveFedora::SolrService).to receive_messages(:instance =>double("instance", :conn=>mock_conn))
+      expect(ActiveFedora::SolrService.count('querytext')).to eq(7) 
     end
     it "should accept query args" do
       mock_conn = double("Connection")
       stub_result = {'response' => {'numFound'=>'7'}}
-      mock_conn.should_receive(:get).with('select', :params=>{:rows=>0, :q=>'querytext', :qt=>'standard', :fq=>'filter'}).and_return(stub_result)
-      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
-      ActiveFedora::SolrService.count('querytext', :fq=>'filter', :rows=>10).should == 7 
+      expect(mock_conn).to receive(:get).with('select', :params=>{:rows=>0, :q=>'querytext', :qt=>'standard', :fq=>'filter'}).and_return(stub_result)
+      allow(ActiveFedora::SolrService).to receive_messages(:instance =>double("instance", :conn=>mock_conn))
+      expect(ActiveFedora::SolrService.count('querytext', :fq=>'filter', :rows=>10)).to eq(7) 
     end
   end
   describe ".add" do
     it "should call solr" do 
       mock_conn = double("Connection")
       doc = {'id' => '1234'}
-      mock_conn.should_receive(:add).with(doc, {:params=>{}})
-      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
+      expect(mock_conn).to receive(:add).with(doc, {:params=>{}})
+      allow(ActiveFedora::SolrService).to receive_messages(:instance =>double("instance", :conn=>mock_conn))
       ActiveFedora::SolrService.add(doc)
     end
   end
@@ -147,8 +147,8 @@ describe ActiveFedora::SolrService do
     it "should call solr" do 
       mock_conn = double("Connection")
       doc = {'id' => '1234'}
-      mock_conn.should_receive(:commit)
-      ActiveFedora::SolrService.stub(:instance =>double("instance", :conn=>mock_conn))
+      expect(mock_conn).to receive(:commit)
+      allow(ActiveFedora::SolrService).to receive_messages(:instance =>double("instance", :conn=>mock_conn))
       ActiveFedora::SolrService.commit()
     end
   end