active-fedora 8.2.1 → 8.2.2

data/spec/unit/persistence_spec.rb

@@ -15,13 +15,13 @@ describe ActiveFedora::Persistence do
 
     describe "#create_needs_index?" do
       it "should be true" do
-        subject.send(:create_needs_index?).should be_true
+        expect(subject.send(:create_needs_index?)).to be_truthy
       end
     end
 
     describe "#update_needs_index?" do
       it "should be true" do
-        subject.send(:update_needs_index?).should be_true
+        expect(subject.send(:update_needs_index?)).to be_truthy
       end
     end
   end

data/spec/unit/predicates_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe ActiveFedora::Predicates do
   describe "#short_predicate" do
     it 'should parse strings' do
-      ActiveFedora::Predicates.short_predicate('http://www.openarchives.org/OAI/2.0/itemID').should == :oai_item_id
+      expect(ActiveFedora::Predicates.short_predicate('http://www.openarchives.org/OAI/2.0/itemID')).to eq(:oai_item_id)
     end
     it 'should parse uris' do
-      ActiveFedora::Predicates.short_predicate(RDF::DC.creator).should == 'dc_terms_creator'
-      ActiveFedora::Predicates.short_predicate(RDF::SKOS.hasTopConcept).should == '2004_02_skos_core_has_top_concept'
+      expect(ActiveFedora::Predicates.short_predicate(RDF::DC.creator)).to eq('dc_terms_creator')
+      expect(ActiveFedora::Predicates.short_predicate(RDF::SKOS.hasTopConcept)).to eq('2004_02_skos_core_has_top_concept')
     end
     before(:all) do
       @original_mapping = ActiveFedora::Predicates.predicate_config[:predicate_mapping]
@@ -21,25 +21,25 @@ describe ActiveFedora::Predicates do
         "http://example.org/zoo/wolves/"=>{:alpha => 'Manager'},
         "http://example.org/zoo/"=>{:keeper => 'Manager'}
         }
-      ActiveFedora::Predicates.short_predicate("http://example.org/zoo/Manager").should == :keeper
-      ActiveFedora::Predicates.short_predicate("http://example.org/zoo/wolves/Manager").should == :alpha
-      ActiveFedora::Predicates.short_predicate("http://example.org/Manager").should == :ceo
+      expect(ActiveFedora::Predicates.short_predicate("http://example.org/zoo/Manager")).to eq(:keeper)
+      expect(ActiveFedora::Predicates.short_predicate("http://example.org/zoo/wolves/Manager")).to eq(:alpha)
+      expect(ActiveFedora::Predicates.short_predicate("http://example.org/Manager")).to eq(:ceo)
     end
   end
   
   it 'should provide .default_predicate_namespace' do
-    ActiveFedora::Predicates.default_predicate_namespace.should == 'info:fedora/fedora-system:def/relations-external#'
+    expect(ActiveFedora::Predicates.default_predicate_namespace).to eq('info:fedora/fedora-system:def/relations-external#')
   end
  
   describe "#predicate_mappings" do 
 
     it 'should return a hash' do
-      ActiveFedora::Predicates.predicate_mappings.should be_kind_of Hash
+      expect(ActiveFedora::Predicates.predicate_mappings).to be_kind_of Hash
     end
 
     it "should provide mappings to the fedora ontology via the info:fedora/fedora-system:def/relations-external default namespace mapping" do
-      ActiveFedora::Predicates.predicate_mappings.keys.include?(ActiveFedora::Predicates.default_predicate_namespace).should be_true
-      ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace].should be_kind_of Hash
+      expect(ActiveFedora::Predicates.predicate_mappings.keys.include?(ActiveFedora::Predicates.default_predicate_namespace)).to be_truthy
+      expect(ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace]).to be_kind_of Hash
     end
 
     it 'should provide predicate mappings for entire Fedora Relationship Ontology' do
@@ -67,21 +67,21 @@ describe ActiveFedora::Predicates do
                             :conforms_to => "conformsTo",
                             :has_model => "hasModel"]
       desired_mappings.each_pair do |k,v|
-        ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace].should have_key(k)
-        ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace][k].should == v
+        expect(ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace]).to have_key(k)
+        expect(ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace][k]).to eq(v)
       end
     end
   end
 
   it 'should provide #predicate_lookup that maps symbols to common RELS-EXT predicates' do
-    ActiveFedora::Predicates.should respond_to(:predicate_lookup)
-    ActiveFedora::Predicates.predicate_lookup(:is_part_of).should == "isPartOf"
-    ActiveFedora::Predicates.predicate_lookup(:is_member_of).should == "isMemberOf"
-    ActiveFedora::Predicates.predicate_lookup("isPartOfCollection").should == "isPartOfCollection"
+    expect(ActiveFedora::Predicates).to respond_to(:predicate_lookup)
+    expect(ActiveFedora::Predicates.predicate_lookup(:is_part_of)).to eq("isPartOf")
+    expect(ActiveFedora::Predicates.predicate_lookup(:is_member_of)).to eq("isMemberOf")
+    expect(ActiveFedora::Predicates.predicate_lookup("isPartOfCollection")).to eq("isPartOfCollection")
     ActiveFedora::Predicates.predicate_config[:predicate_mapping].merge!({"some_namespace"=>{:has_foo=>"hasFOO"}})
-    ActiveFedora::Predicates.find_predicate(:has_foo).should == ["hasFOO","some_namespace"]
-    ActiveFedora::Predicates.predicate_lookup(:has_foo,"some_namespace").should == "hasFOO"
-    lambda { ActiveFedora::Predicates.predicate_lookup(:has_foo) }.should raise_error ActiveFedora::UnregisteredPredicateError
+    expect(ActiveFedora::Predicates.find_predicate(:has_foo)).to eq(["hasFOO","some_namespace"])
+    expect(ActiveFedora::Predicates.predicate_lookup(:has_foo,"some_namespace")).to eq("hasFOO")
+    expect { ActiveFedora::Predicates.predicate_lookup(:has_foo) }.to raise_error ActiveFedora::UnregisteredPredicateError
   end
     
   context 'initialization' do
@@ -94,19 +94,19 @@ describe ActiveFedora::Predicates do
     end
     
     it 'should allow explicit initialization of predicates' do
-      ActiveFedora::Predicates.find_predicate(:is_part_of).should == ["isPartOf", "info:fedora/fedora-system:def/relations-external#"]
+      expect(ActiveFedora::Predicates.find_predicate(:is_part_of)).to eq(["isPartOf", "info:fedora/fedora-system:def/relations-external#"])
       ActiveFedora::Predicates.predicate_config = {
         :default_namespace => 'http://example.com/foo',
         :predicate_mapping => {
           'http://example.com/foo' => { :has_bar => 'hasBAR' }
         }
       }
-      ActiveFedora::Predicates.find_predicate(:has_bar).should == ["hasBAR", "http://example.com/foo"]
-      lambda { ActiveFedora::Predicates.find_predicate(:is_part_of) }.should raise_error ActiveFedora::UnregisteredPredicateError
+      expect(ActiveFedora::Predicates.find_predicate(:has_bar)).to eq(["hasBAR", "http://example.com/foo"])
+      expect { ActiveFedora::Predicates.find_predicate(:is_part_of) }.to raise_error ActiveFedora::UnregisteredPredicateError
     end
     
     it 'should ensure that the configuration has the correct keys' do
-      lambda { ActiveFedora::Predicates.predicate_config = { :foo => 'invalid!' } }.should raise_error TypeError
+      expect { ActiveFedora::Predicates.predicate_config = { :foo => 'invalid!' } }.to raise_error TypeError
     end
 
     it "should allow adding predicates without wiping out existing predicates" do
@@ -118,12 +118,12 @@ describe ActiveFedora::Predicates do
                                                   },
                                               })
       # New & Modified Predicates
-      ActiveFedora::Predicates.find_predicate(:has_profile).should == ["hasProfile", "http://projecthydra.org/ns/relations#"]
-      ActiveFedora::Predicates.find_predicate(:references).should == ["references", "info:fedora/fedora-system:def/relations-external#"]
-      ActiveFedora::Predicates.find_predicate(:has_derivation).should == ["cameFrom", "info:fedora/fedora-system:def/relations-external#"]
+      expect(ActiveFedora::Predicates.find_predicate(:has_profile)).to eq(["hasProfile", "http://projecthydra.org/ns/relations#"])
+      expect(ActiveFedora::Predicates.find_predicate(:references)).to eq(["references", "info:fedora/fedora-system:def/relations-external#"])
+      expect(ActiveFedora::Predicates.find_predicate(:has_derivation)).to eq(["cameFrom", "info:fedora/fedora-system:def/relations-external#"])
       # Pre-Existing predicates should be unharmed
-      ActiveFedora::Predicates.find_predicate(:is_part_of).should == ["isPartOf", "info:fedora/fedora-system:def/relations-external#"]
-      ActiveFedora::Predicates.find_predicate(:is_governed_by).should == ["isGovernedBy", "http://projecthydra.org/ns/relations#"]
+      expect(ActiveFedora::Predicates.find_predicate(:is_part_of)).to eq(["isPartOf", "info:fedora/fedora-system:def/relations-external#"])
+      expect(ActiveFedora::Predicates.find_predicate(:is_governed_by)).to eq(["isGovernedBy", "http://projecthydra.org/ns/relations#"])
     end
 
   end

data/spec/unit/property_spec.rb

@@ -6,27 +6,27 @@ require 'active_fedora/model'
 describe ActiveFedora::Property do
   
   before(:all) do
-    @test_property = ActiveFedora::Property.new(stub("model_stub"),"file_name", :string)
+    @test_property = ActiveFedora::Property.new(double("model_stub"),"file_name", :string)
   end
   
   it 'should provide .new' do
-    ActiveFedora::Property.should respond_to(:new)
+    expect(ActiveFedora::Property).to respond_to(:new)
   end
 
   it 'should provide .name' do
-    ActiveFedora::Property.should respond_to(:name)
+    expect(ActiveFedora::Property).to respond_to(:name)
   end
 
   
   it 'should provide .instance_variable_name' do
     #ActiveFedora::Property.should respond_to(:instance_variable_name)
     
-    @test_property.should respond_to(:instance_variable_name)
+    expect(@test_property).to respond_to(:instance_variable_name)
   end
 
   describe '.instance_variable_name' do
     it 'should return the value of the name attribute with an @ appended' do
-      @test_property.instance_variable_name.should eql("@#{@test_property.name}")
+      expect(@test_property.instance_variable_name).to eql("@#{@test_property.name}")
     end
   end
   

data/spec/unit/qualified_dublin_core_datastream_spec.rb

@@ -41,21 +41,21 @@ describe ActiveFedora::QualifiedDublinCoreDatastream 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
 
   it "should create the right number of fields" do
-    ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS.size.should == 54
+    expect(ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS.size).to eq(54)
   end
 
   it "should have unmodifiable constants" do
-    proc {ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS<<:foo}.should raise_error((TypeError if RUBY_VERSION < "1.9.0") || RuntimeError, /can't modify frozen array/i)
+    expect {ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS<<:foo}.to raise_error((TypeError if RUBY_VERSION < "1.9.0") || RuntimeError, /can't modify frozen array/i)
 
   end
 
   it "should default dc elements to :multiple=>true" do
     @test_ds.fields.values.each do |s|
-      s.has_key?(:multiple).should == true
+      expect(s.has_key?(:multiple)).to eq(true)
     end
   end
   
@@ -64,7 +64,7 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
   
   describe '#new' do
     it 'should provide #new' do
-      ActiveFedora::QualifiedDublinCoreDatastream.should respond_to(:new)
+      expect(ActiveFedora::QualifiedDublinCoreDatastream).to respond_to(:new)
     end
     
     
@@ -75,7 +75,7 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
           pending if el == :type
           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
     end
@@ -95,7 +95,7 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
       @test_ds.creator= ["creator1", "creator2"]
       @test_ds.title= ["title1"]
 
-      @test_ds.to_xml.should be_equivalent_to('
+      expect(@test_ds.to_xml).to be_equivalent_to('
         <dc xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
                  <dcterms:publisher>publisher1</dcterms:publisher>
                  <dcterms:creator>creator1</dcterms:creator>
@@ -110,7 +110,7 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
       @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.new(nil, 'qdc' )
       @test_ds.title = "War and Peace"
       solr = @test_ds.to_solr
-      solr[ActiveFedora::SolrService.solr_name('title', type: :string)].should == "War and Peace"
+      expect(solr[ActiveFedora::SolrService.solr_name('title', type: :string)]).to eq("War and Peace")
     end
 
   end
@@ -120,7 +120,7 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
       sample_xml = "<dc xmlns:dcterms='http://purl.org/dc/terms/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><dcterms:cust>custom</dcterms:cust></dc>"
       test_ds = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(sample_xml )
       test_ds.field :cust
-      test_ds.cust.should == ['custom']
+      expect(test_ds.cust).to eq(['custom'])
     end
   end
 
@@ -128,7 +128,7 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
     it "should be able to map :dc_type to the path 'type'" do
       test_ds = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(@sample_xml)
       test_ds.field :dc_type, :string, path: "type", multiple: true
-      test_ds.dc_type.should == ['sound']
+      expect(test_ds.dc_type).to eq(['sound'])
     end
   end
 

data/spec/unit/query_spec.rb

@@ -16,27 +16,27 @@ describe ActiveFedora::Base do
   end
 
   describe ":all" do
-    before { ActiveFedora::Base.stub(:relation => relation) }
+    before { allow(ActiveFedora::Base).to receive_messages(:relation => relation) }
     describe "called on a concrete class" do
       let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
       it "should query solr for all objects with :has_model_s of self.class" do
-        relation.should_receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
-        relation.should_receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
+        expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
+        expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
         mock_docs = [{"id" => "changeme:30"}, {"id" => "changeme:22"}]
-        mock_docs.should_receive(:has_next?).and_return(false)
-        ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
-        SpecModel::Basic.all.should == ["Fake Object1", "Fake Object2"]
+        expect(mock_docs).to receive(:has_next?).and_return(false)
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
+        expect(SpecModel::Basic.all).to eq(["Fake Object1", "Fake Object2"])
       end
     end
     describe "called without a specific class" do
       let(:relation) { ActiveFedora::Relation.new(ActiveFedora::Base) }
       it "should specify a q parameter" do
-        relation.should_receive(:load_from_fedora).with("changeme:30", true).and_return("Fake Object1")
-        relation.should_receive(:load_from_fedora).with("changeme:22", true).and_return("Fake Object2")
+        expect(relation).to receive(:load_from_fedora).with("changeme:30", true).and_return("Fake Object1")
+        expect(relation).to receive(:load_from_fedora).with("changeme:22", true).and_return("Fake Object2")
         mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
-        mock_docs.should_receive(:has_next?).and_return(false)
-        ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>'*:*', :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
-        ActiveFedora::Base.all.should == ["Fake Object1", "Fake Object2"]
+        expect(mock_docs).to receive(:has_next?).and_return(false)
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate).with(1, 1000, 'select', :params=>{:q=>'*:*', :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
+        expect(ActiveFedora::Base.all).to eq(["Fake Object1", "Fake Object2"])
       end
     end
   end
@@ -46,37 +46,37 @@ describe ActiveFedora::Base do
       describe "and a pid is specified" do
         it "should use SpecModel::Basic.allocate.init_with_object to instantiate an object" do
           allow_any_instance_of(SpecModel::Basic).to receive(:init_with_object).and_return(SpecModel::Basic.new )
-          ActiveFedora::DigitalObject.should_receive(:find).and_return(double("inner obj", :'new?'=>false))
-          SpecModel::Basic.find("_PID_", cast: false).should be_a SpecModel::Basic
+          expect(ActiveFedora::DigitalObject).to receive(:find).and_return(double("inner obj", :'new?'=>false))
+          expect(SpecModel::Basic.find("_PID_", cast: false)).to be_a SpecModel::Basic
         end
         it "should raise an exception if it is not found" do
           allow_any_instance_of(Rubydora::Fc3Service).to receive(:object).and_raise(RestClient::ResourceNotFound)
-          SpecModel::Basic.should_receive(:connection_for_pid).with("_PID_")
-          lambda {SpecModel::Basic.find("_PID_")}.should raise_error ActiveFedora::ObjectNotFoundError
+          expect(SpecModel::Basic).to receive(:connection_for_pid).with("_PID_")
+          expect {SpecModel::Basic.find("_PID_")}.to raise_error ActiveFedora::ObjectNotFoundError
         end
       end
     end
     describe "with default :cast of true" do
       it "should use SpecModel::Basic.allocate.init_with_object to instantiate an object" do
         allow_any_instance_of(SpecModel::Basic).to receive(:init_with_object).and_return(double("Model", :adapt_to_cmodel=>SpecModel::Basic.new ))
-        ActiveFedora::DigitalObject.should_receive(:find).and_return(double("inner obj", :'new?'=>false))
+        expect(ActiveFedora::DigitalObject).to receive(:find).and_return(double("inner obj", :'new?'=>false))
         SpecModel::Basic.find("_PID_")
       end
     end
 
     describe "with conditions" do
       before do
-        ActiveFedora::Base.stub(:relation => relation)
-        relation.stub(clone: relation)
+        allow(ActiveFedora::Base).to receive_messages(:relation => relation)
+        allow(relation).to receive_messages(clone: relation)
       end
       let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
       it "should filter by the provided fields" do
-        relation.should_receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
-        relation.should_receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
+        expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
+        expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
 
         mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
-        mock_docs.should_receive(:has_next?).and_return(false)
-        ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with() { |page, rows, method, hash|
+        expect(mock_docs).to receive(:has_next?).and_return(false)
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
             page == 1 &&
             rows == 1000 &&
             method == 'select' &&
@@ -88,24 +88,24 @@ describe ActiveFedora::Base do
             hash[:params][:q].split(" AND ").include?("baz:quix") &&
             hash[:params][:q].split(" AND ").include?("baz:quack")
         }.and_return('response'=>{'docs'=>mock_docs})
-        SpecModel::Basic.find({:foo=>'bar', :baz=>['quix','quack']}).should == ["Fake Object1", "Fake Object2"]
+        expect(SpecModel::Basic.find({:foo=>'bar', :baz=>['quix','quack']})).to eq(["Fake Object1", "Fake Object2"])
       end
 
       it "should correctly query for empty strings" do
-        SpecModel::Basic.find( :active_fedora_model_ssi => '').count.should == 0
+        expect(SpecModel::Basic.find( :active_fedora_model_ssi => '').count).to eq(0)
       end
 
       it 'should correctly query for empty arrays' do
-        SpecModel::Basic.find( :active_fedora_model_ssi => []).count.should == 0
+        expect(SpecModel::Basic.find( :active_fedora_model_ssi => []).count).to eq(0)
       end
 
       it "should add options" do
-        relation.should_receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
-        relation.should_receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
+        expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
+        expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
 
         mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
-        mock_docs.should_receive(:has_next?).and_return(false)
-        ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with() { |page, rows, method, hash|
+        expect(mock_docs).to receive(:has_next?).and_return(false)
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
             page == 1 &&
             rows == 1000 &&
             method == 'select' &&
@@ -117,34 +117,34 @@ describe ActiveFedora::Base do
             hash[:params][:q].split(" AND ").include?("baz:quix") &&
             hash[:params][:q].split(" AND ").include?("baz:quack")
         }.and_return('response'=>{'docs'=>mock_docs})
-        SpecModel::Basic.find({:foo=>'bar', :baz=>['quix','quack']}, :sort=>'title_t desc').should == ["Fake Object1", "Fake Object2"]
+        expect(SpecModel::Basic.find({:foo=>'bar', :baz=>['quix','quack']}, :sort=>'title_t desc')).to eq(["Fake Object1", "Fake Object2"])
       end
     end
   end
 
 
   describe '#find_each' do
-    before { ActiveFedora::Base.stub(:relation => relation) }
+    before { allow(ActiveFedora::Base).to receive_messages(:relation => relation) }
     let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
     it "should query solr for all objects with :active_fedora_model_s of self.class" do
       mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
-      mock_docs.should_receive(:has_next?).and_return(false)
-      ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
+      expect(mock_docs).to receive(:has_next?).and_return(false)
+      expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
       
-      relation.should_receive(:load_from_fedora).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
-      relation.should_receive(:load_from_fedora).with("changeme:22", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:22'))
+      expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
+      expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:22'))
       yielded = double("yielded method")
-      yielded.should_receive(:run).with { |obj| obj.class == SpecModel::Basic}.twice
+      expect(yielded).to receive(:run).twice { |obj| obj.class == SpecModel::Basic}
       SpecModel::Basic.find_each(){|obj| yielded.run(obj) }
     end
     describe "with conditions" do
       it "should filter by the provided fields" do
-        relation.should_receive(:load_from_fedora).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
-        relation.should_receive(:load_from_fedora).with("changeme:22", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:22'))
+        expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
+        expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:22'))
 
         mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
-        mock_docs.should_receive(:has_next?).and_return(false)
-        ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with() { |page, rows, method, hash|
+        expect(mock_docs).to receive(:has_next?).and_return(false)
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
             page == 1 &&
             rows == 1000 &&
             method == 'select' &&
@@ -157,7 +157,7 @@ describe ActiveFedora::Base do
             hash[:params][:q].split(" AND ").include?("baz:quack")
         }.and_return('response'=>{'docs'=>mock_docs})
         yielded = double("yielded method")
-        yielded.should_receive(:run).with { |obj| obj.class == SpecModel::Basic}.twice
+        expect(yielded).to receive(:run).twice { |obj| obj.class == SpecModel::Basic}
         SpecModel::Basic.find_each({:foo=>'bar', :baz=>['quix','quack']}){|obj| yielded.run(obj) }
       end
     end
@@ -167,8 +167,8 @@ describe ActiveFedora::Base do
     describe "with conditions hash" do
       it "should filter by the provided fields" do
         mock_docs = double('docs')
-        mock_docs.should_receive(:has_next?).and_return(false)
-        ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with() { |page, rows, method, hash|
+        expect(mock_docs).to receive(:has_next?).and_return(false)
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
             page == 1 &&
             rows == 1002 &&
             method == 'select' &&
@@ -181,8 +181,8 @@ describe ActiveFedora::Base do
             hash[:params][:q].split(" AND ").include?("baz:quack")
         }.and_return('response'=>{'docs'=>mock_docs})
         yielded = double("yielded method")
-        yielded.should_receive(:run).with(mock_docs)
-        SpecModel::Basic.find_in_batches({:foo=>'bar', :baz=>['quix','quack']}, {:batch_size=>1002, :fl=>'id'}){|group| yielded.run group }.should
+        expect(yielded).to receive(:run).with(mock_docs)
+        SpecModel::Basic.find_in_batches({:foo=>'bar', :baz=>['quix','quack']}, {:batch_size=>1002, :fl=>'id'}) {|group| yielded.run group }
       end
     end
   end
@@ -191,19 +191,19 @@ describe ActiveFedora::Base do
     
     it "should return a count" do
       mock_result = {'response'=>{'numFound'=>7}}
-      ActiveFedora::SolrService.should_receive(:query).with(@model_query, :rows=>0, :raw=>true).and_return(mock_result)
-      SpecModel::Basic.count.should == 7
+      expect(ActiveFedora::SolrService).to receive(:query).with(@model_query, :rows=>0, :raw=>true).and_return(mock_result)
+      expect(SpecModel::Basic.count).to eq(7)
     end
     it "should allow conditions" do
       mock_result = {'response'=>{'numFound'=>7}}
-      ActiveFedora::SolrService.should_receive(:query).with("#{@model_query} AND (foo:bar)", :rows=>0, :raw=>true).and_return(mock_result)
-      SpecModel::Basic.count(:conditions=>'foo:bar').should == 7
+      expect(ActiveFedora::SolrService).to receive(:query).with("#{@model_query} AND (foo:bar)", :rows=>0, :raw=>true).and_return(mock_result)
+      expect(SpecModel::Basic.count(:conditions=>'foo:bar')).to eq(7)
     end
 
     it "should count without a class specified" do
       mock_result = {'response'=>{'numFound'=>7}}
-      ActiveFedora::SolrService.should_receive(:query).with("(foo:bar)", :rows=>0, :raw=>true).and_return(mock_result)
-      ActiveFedora::Base.count(:conditions=>'foo:bar').should == 7 
+      expect(ActiveFedora::SolrService).to receive(:query).with("(foo:bar)", :rows=>0, :raw=>true).and_return(mock_result)
+      expect(ActiveFedora::Base.count(:conditions=>'foo:bar')).to eq(7) 
     end
   end
 
@@ -252,7 +252,7 @@ describe ActiveFedora::Base do
   describe '#find_with_conditions' do
     it "should make a query to solr and return the results" do
       mock_result = double('Result')
-           ActiveFedora::SolrService.should_receive(:query).with() { |args|
+           expect(ActiveFedora::SolrService).to receive(:query) { |args|
             q = args.first if args.is_a? Array
             q ||= args
             q.split(" AND ").include?(@model_query) &&
@@ -260,32 +260,32 @@ describe ActiveFedora::Base do
             q.split(" AND ").include?("baz:quix") &&
             q.split(" AND ").include?("baz:quack")
         }.and_return(mock_result)
-      SpecModel::Basic.find_with_conditions(:foo=>'bar', :baz=>['quix','quack']).should == mock_result
+      expect(SpecModel::Basic.find_with_conditions(:foo=>'bar', :baz=>['quix','quack'])).to eq(mock_result)
     end
 
     it "should escape quotes" do
       mock_result = double('Result')
-           ActiveFedora::SolrService.should_receive(:query).with() { |args|
-            q = args.first if args.is_a? Array
-            q ||= args
-            q.split(" AND ").include?(@model_query) &&
-            q.split(" AND ").include?(@model_query) &&
-            q.split(" AND ").include?('foo:9\\"\\ Nails') &&
-            q.split(" AND ").include?('baz:7\\"\\ version') &&
-            q.split(" AND ").include?('baz:quack')
+      expect(ActiveFedora::SolrService).to receive(:query) { |args|
+          q = args.first if args.is_a? Array
+          q ||= args
+          q.split(" AND ").include?(@model_query) &&
+          q.split(" AND ").include?(@model_query) &&
+          q.split(" AND ").include?('foo:9\\"\\ Nails') &&
+          q.split(" AND ").include?('baz:7\\"\\ version') &&
+          q.split(" AND ").include?('baz:quack')
         }.and_return(mock_result)
-      SpecModel::Basic.find_with_conditions(:foo=>'9" Nails', :baz=>['7" version','quack']).should == mock_result
+      expect(SpecModel::Basic.find_with_conditions(:foo=>'9" Nails', :baz=>['7" version','quack'])).to eq(mock_result)
     end
 
     it "shouldn't use the class if it's called on AF:Base " do
       mock_result = double('Result')
-      ActiveFedora::SolrService.should_receive(:query).with('baz:quack', {:sort => [@sort_query]}).and_return(mock_result)
-      ActiveFedora::Base.find_with_conditions(:baz=>'quack').should == mock_result
+      expect(ActiveFedora::SolrService).to receive(:query).with('baz:quack', {:sort => [@sort_query]}).and_return(mock_result)
+      expect(ActiveFedora::Base.find_with_conditions(:baz=>'quack')).to eq(mock_result)
     end
     it "should use the query string if it's provided and wrap it in parentheses" do
       mock_result = double('Result')
-      ActiveFedora::SolrService.should_receive(:query).with('(chunky:monkey)', {:sort => [@sort_query]}).and_return(mock_result)
-      ActiveFedora::Base.find_with_conditions('chunky:monkey').should == mock_result
+      expect(ActiveFedora::SolrService).to receive(:query).with('(chunky:monkey)', {:sort => [@sort_query]}).and_return(mock_result)
+      expect(ActiveFedora::Base.find_with_conditions('chunky:monkey')).to eq(mock_result)
     end
   end