active-fedora 6.7.8 → 6.8.0

data/spec/unit/persistence_spec.rb

@@ -12,15 +12,15 @@ describe ActiveFedora::Persistence do
 
   subject { SpecNode.new }
 
-  describe "#create_needs_index?" do
-    it "should be true" do
-      subject.send(:create_needs_index?).should be_true
+  describe '#create_needs_index?' do
+    it 'should be true' do
+      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
+  describe '#update_needs_index?' do
+      it 'should be true' do
+        expect(subject.send(:update_needs_index?)).to be_truthy
       end
   end
 

data/spec/unit/predicates_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe ActiveFedora::Predicates do
-  describe "#short_predicate" 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]
@@ -15,117 +15,117 @@ describe ActiveFedora::Predicates do
     after(:all) do
       ActiveFedora::Predicates.predicate_config[:predicate_mapping] = @original_mapping
     end
-    it "should find predicates regardless of order loaded or shared namespace prefixes" do
+    it 'should find predicates regardless of order loaded or shared namespace prefixes' do
       ActiveFedora::Predicates.predicate_config[:predicate_mapping] = {
-        "http://example.org/"=>{:ceo => 'Manager'},
-        "http://example.org/zoo/wolves/"=>{:alpha => 'Manager'},
-        "http://example.org/zoo/"=>{:keeper => 'Manager'}
+        'http://example.org/' => {:ceo => 'Manager'},
+        '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 
+
+  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
+    it 'should provide mappings to the fedora ontology via the info:fedora/fedora-system:def/relations-external default namespace mapping' do
+      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
-      desired_mappings = Hash[:is_member_of => "isMemberOf",
-                            :has_member => "hasMember",
-                            :is_part_of => "isPartOf",
-                            :has_part => "hasPart",
-                            :is_member_of_collection => "isMemberOfCollection",
-                            :has_collection_member => "hasCollectionMember",
-                            :is_constituent_of => "isConstituentOf",
-                            :has_constituent => "hasConstituent",
-                            :is_subset_of => "isSubsetOf",
-                            :has_subset => "hasSubset",
-                            :is_derivation_of => "isDerivationOf",
-                            :has_derivation => "hasDerivation",
-                            :is_dependent_of => "isDependentOf",
-                            :has_dependent => "hasDependent",
-                            :is_description_of => "isDescriptionOf",
-                            :has_description => "hasDescription",
-                            :is_metadata_for => "isMetadataFor",
-                            :has_metadata => "hasMetadata",
-                            :is_annotation_of => "isAnnotationOf",
-                            :has_annotation => "hasAnnotation",
-                            :has_equivalent => "hasEquivalent",
-                            :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
+      desired_mappings = Hash[:is_member_of => 'isMemberOf',
+                            :has_member => 'hasMember',
+                            :is_part_of => 'isPartOf',
+                            :has_part => 'hasPart',
+                            :is_member_of_collection => 'isMemberOfCollection',
+                            :has_collection_member => 'hasCollectionMember',
+                            :is_constituent_of => 'isConstituentOf',
+                            :has_constituent => 'hasConstituent',
+                            :is_subset_of => 'isSubsetOf',
+                            :has_subset => 'hasSubset',
+                            :is_derivation_of => 'isDerivationOf',
+                            :has_derivation => 'hasDerivation',
+                            :is_dependent_of => 'isDependentOf',
+                            :has_dependent => 'hasDependent',
+                            :is_description_of => 'isDescriptionOf',
+                            :has_description => 'hasDescription',
+                            :is_metadata_for => 'isMetadataFor',
+                            :has_metadata => 'hasMetadata',
+                            :is_annotation_of => 'isAnnotationOf',
+                            :has_annotation => 'hasAnnotation',
+                            :has_equivalent => 'hasEquivalent',
+                            :conforms_to => 'conformsTo',
+                            :has_model => 'hasModel']
+      desired_mappings.each_pair do |k, 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"
-    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).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'}})
+    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
     before :each do
       @old_predicate_config = ActiveFedora::Predicates.predicate_config
     end
-    
+
     after :each do
       ActiveFedora::Predicates.predicate_config = @old_predicate_config
     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
+    it 'should allow adding predicates without wiping out existing predicates' do
       ActiveFedora::Predicates.set_predicates({
-                                                  "http://projecthydra.org/ns/relations#"=>{has_profile:"hasProfile"},
-                                                  "info:fedora/fedora-system:def/relations-external#"=>{
-                                                      references:"references",
-                                                      has_derivation: "cameFrom"
-                                                  },
+                                                  'http://projecthydra.org/ns/relations#' => {has_profile: 'hasProfile'},
+                                                  'info:fedora/fedora-system:def/relations-external#' => {
+                                                      references: 'references',
+                                                      has_derivation: 'cameFrom'
+                                                  }
                                               })
       # 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
-  
+
 end

data/spec/unit/property_spec.rb

@@ -4,30 +4,22 @@ require 'active_fedora'
 require 'active_fedora/model'
 
 describe ActiveFedora::Property do
-  
-  before(:all) do
-    @test_property = ActiveFedora::Property.new(stub("model_stub"),"file_name", :string)
-  end
-  
-  it 'should provide .new' do
-    ActiveFedora::Property.should respond_to(:new)
-  end
 
-  it 'should provide .name' do
-    ActiveFedora::Property.should respond_to(:name)
+  before :each do
+    mstub = double('model_stub')
+    @test_property = ActiveFedora::Property.new(mstub, 'file_name', :string)
   end
 
-  
-  it 'should provide .instance_variable_name' do
-    #ActiveFedora::Property.should respond_to(:instance_variable_name)
-    
-    @test_property.should respond_to(:instance_variable_name)
+  it 'should provide .new and .name' do
+    expect(ActiveFedora::Property).to respond_to(:new)
+    expect(ActiveFedora::Property).to respond_to(: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).to respond_to(:instance_variable_name)
+      expect(@test_property.instance_variable_name).to eql("@#{@test_property.name}")
     end
   end
-  
+
 end

data/spec/unit/qualified_dublin_core_datastream_spec.rb

@@ -5,10 +5,10 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
 
   before(:all) do
     # Load Sample OralHistory Model
-    require File.join( File.dirname(__FILE__), "..", "samples","oral_history_sample_model" )
+    require File.join( File.dirname(__FILE__), '..', 'samples', 'oral_history_sample_model' )
     @dc_terms = []
   end
-  
+
   before(:each) do
     @sample_xml =  "<dc xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:dcterms='http://purl.org/dc/terms/'>
           <dcterms:type xsi:type='DCMITYPE'>sound</dcterms:type>
@@ -40,47 +40,47 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
      @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(@sample_xml )
 
   end
-  it "from_xml should parse everything correctly" do
-    @test_ds.ng_xml.should be_equivalent_to @sample_xml
+  it 'from_xml should parse everything correctly' do
+    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
+  it 'should create the right number of fields' do
+    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)
+  it 'should have unmodifiable constants' do
+    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
+  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
-  
+
   after(:each) do
   end
-  
+
   describe '#new' do
     it 'should provide #new' do
-      ActiveFedora::QualifiedDublinCoreDatastream.should respond_to(:new)
+      expect(ActiveFedora::QualifiedDublinCoreDatastream).to respond_to(:new)
     end
-    
-    
-    describe "model methods" do 
+
+
+    describe 'model methods' do
 
       DC_ELEMENTS.each do |el|
         it "should respond to getters and setters for #{el} element" do
-          pending if el == :type
+          skip 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
+          @test_ds.send("#{el.to_s}=", value)
+          expect(@test_ds.send(el).first).to eq(value)  #Looking at first because creator has 2 nodes
         end
       end
     end
   end
-  
+
   describe '.to_xml' do
     it 'should output the fields hash as Qualified Dublin Core XML' do
       #@test_ds.should_receive(:new?).and_return(true).twice
@@ -90,12 +90,12 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
       @test_ds.field :publisher
       @test_ds.field :creator
       @test_ds.field :title
-      
-      @test_ds.publisher= ["publisher1"]
-      @test_ds.creator= ["creator1", "creator2"]
-      @test_ds.title= ["title1"]
 
-      @test_ds.to_xml.should be_equivalent_to('
+      @test_ds.publisher = ['publisher1']
+      @test_ds.creator = ['creator1', 'creator2']
+      @test_ds.title = ['title1']
+
+      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>
@@ -105,12 +105,12 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
     end
   end
 
-  describe "#to_solr" do
-    it "should have title" do
+  describe '#to_solr' do
+    it 'should have title' do
       @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.new(nil, 'qdc' )
-      @test_ds.title = "War and Peace"
+      @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,15 +120,15 @@ 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
 
-  describe "#field should accept :path option" do
+  describe '#field should accept :path option' 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']
+      test_ds.field :dc_type, :string, path: 'type', multiple: true
+      expect(test_ds.dc_type).to eq(['sound'])
     end
   end
 

data/spec/unit/query_spec.rb

@@ -1,130 +1,121 @@
 require 'spec_helper'
 
-describe ActiveFedora::Base do
-  
-  before(:all) do
-    module SpecModel
-      class Basic < ActiveFedora::Base
-      end
+module SpecModel
+  class Basic < ActiveFedora::Base
+    def name
+      self.class
     end
-    @model_query = "_query_:\"{!raw f=" + ActiveFedora::SolrService.solr_name("has_model", :symbol) + "}info:fedora/afmodel:SpecModel_Basic" + "\""
-    @sort_query = ActiveFedora::SolrService.solr_name("system_create", :stored_sortable, type: :date) + ' asc'
   end
-  
-  after(:all) do
-    Object.send(:remove_const, :SpecModel)
+end
+
+describe ActiveFedora::Base do
+
+  before :all do
+    @model_query = "_query_:\"{!raw f=" + ActiveFedora::SolrService.solr_name('has_model', :symbol) + '}info:fedora/afmodel:SpecModel_Basic' + "\""
+    @sort_query = ActiveFedora::SolrService.solr_name('system_create', :stored_sortable, type: :date) + ' asc'
   end
-  
+
   describe '#find_one' do
-    describe "when called on AF::Base" do
+    describe 'when called on AF::Base' do
       it 'should notify of deprecation if no cast parameter is passed' do
-        Deprecation.should_receive(:warn).at_least(1).times
-        expect {
-          ActiveFedora::Base.find_one('mypid:99999')
-        }.to raise_error(ActiveFedora::ObjectNotFoundError)
+        expect(Deprecation).to receive(:warn).at_least(1).times
+        expect { ActiveFedora::Base.find_one('mypid:99999') }.to raise_error(ActiveFedora::ObjectNotFoundError)
       end
     end
-    describe "when called on a model extending AF::Base" do
+    describe 'when called on a model extending AF::Base' do
       it 'should not have a deprecation warning when no cast parameter is passed' do
-        Deprecation.should_not_receive(:warn)
-        expect {
-          SpecModel::Basic.find_one('mypid:99999')
-        }.to raise_error(ActiveFedora::ObjectNotFoundError)
+        expect(Deprecation).not_to receive(:warn)
+        expect { SpecModel::Basic.find_one('mypid:99999') }.to raise_error(ActiveFedora::ObjectNotFoundError)
       end
     end
   end
 
   describe '#find' do
-    describe "without :cast" do
-      describe ":all" do
-        describe "called on a concrete class" do
-          it "should query solr for all objects with :has_model_s of self.class" do
-            SpecModel::Basic.should_receive(:find_one).with("changeme:30", nil).and_return("Fake Object1")
-            SpecModel::Basic.should_receive(:find_one).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.find(:all).should == ["Fake Object1", "Fake Object2"]
+    describe 'without :cast' do
+      describe '#all' do
+        describe 'called on a concrete class' do
+          it 'should query solr for all objects with :has_model_s of self.class' do
+            expect(SpecModel::Basic).to receive(:find_one).with('changeme:30', nil).and_return('Fake Object1')
+            expect(SpecModel::Basic).to receive(:find_one).with('changeme:22', nil).and_return('Fake Object2')
+            mock_docs = [{'id' => 'changeme:30'}, {'id' => 'changeme:22'}]
+            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
-          it "should specify a q parameter" do
-            ActiveFedora::Base.should_receive(:find_one).with("changeme:30", true).and_return("Fake Object1")
-            ActiveFedora::Base.should_receive(:find_one).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.find(:all).should == ["Fake Object1", "Fake Object2"]
+        describe 'called without a specific class' do
+          it 'should specify a q parameter' do
+            expect(ActiveFedora::Base).to receive(:find_one).with('changeme:30', true).and_return('Fake Object1')
+            expect(ActiveFedora::Base).to receive(:find_one).with('changeme:22', true).and_return('Fake Object2')
+            mock_docs = [{'id' => 'changeme:30'}, {'id' => 'changeme:22'}]
+            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
-      describe "and a pid is specified" do
-        it "should use SpecModel::Basic.allocate.init_with_object to instantiate an object" 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_").should be_a SpecModel::Basic
+          expect(ActiveFedora::DigitalObject).to receive(:find).and_return(double('inner obj', :'new?' => false))
+          expect(SpecModel::Basic.find('_PID_')).to be_a SpecModel::Basic
         end
-        it "should raise an exception if it is not found" do
+        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 :cast" 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))
-        SpecModel::Basic.find("_PID_", :cast=>true)
+    describe 'with :cast' 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 ))
+        expect(ActiveFedora::DigitalObject).to receive(:find).and_return(double('inner obj', :'new?' => false))
+        SpecModel::Basic.find('_PID_', :cast => true)
       end
     end
 
-    describe "with conditions" do
-      it "should filter by the provided fields" do
-        SpecModel::Basic.should_receive(:find_one).with("changeme:30", nil).and_return("Fake Object1")
-        SpecModel::Basic.should_receive(:find_one).with("changeme:22", nil).and_return("Fake Object2")
+    describe 'with conditions' do
+      it 'should filter by the provided fields' do
+        expect(SpecModel::Basic).to receive(:find_one).with('changeme:30', nil).and_return('Fake Object1')
+        expect(SpecModel::Basic).to receive(:find_one).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|
-            page == 1 &&
-            rows == 1000 &&
-            method == 'select' &&
-            hash[:params] &&
-            hash[:params][:sort] == [@sort_query] &&
-            hash[:params][:fl] == 'id' && 
-            hash[:params][:q].split(" AND ").include?(@model_query) &&
-            hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
-            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"]
+        mock_docs = [{'id' => 'changeme:30'}, {'id' => 'changeme:22'}]
+        expect(mock_docs).to receive(:has_next?).and_return(false)
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
+          expect(page).to eq(1)
+          expect(rows).to eq(1000)
+          expect(method).to eq('select')
+          expect(hash[:params]).to be_a(Hash)
+          expect(hash[:params]).to include(:sort => [@sort_query])
+          expect(hash[:params]).to include(:fl   => 'id')
+          qs = hash[:params][:q].split(' AND ')
+          expect(qs).to include(@model_query, "foo:\"bar\"", "baz:\"quix\"", "baz:\"quack\"")
+        }.and_return('response' => {'docs' => mock_docs})
+        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
+      it 'should correctly query for empty strings' do
+        expect(SpecModel::Basic.find(:active_fedora_model_ssi => '').count).to eq(0)
       end
 
-      it "should add options" do
-        SpecModel::Basic.should_receive(:find_one).with("changeme:30", nil).and_return("Fake Object1")
-        SpecModel::Basic.should_receive(:find_one).with("changeme:22", nil).and_return("Fake Object2")
+      it 'should add options' do
+        expect(SpecModel::Basic).to receive(:find_one).with('changeme:30', nil).and_return('Fake Object1')
+        expect(SpecModel::Basic).to receive(:find_one).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|
-            page == 1 &&
-            rows == 1000 &&
-            method == 'select' &&
-            hash[:params] &&
-            hash[:params][:fl] == 'id' && 
-            hash[:params][:sort] == [@sort_query] &&
-            hash[:params][:q].split(" AND ").include?(@model_query) &&
-            hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
-            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"]
+        mock_docs = [{'id' => 'changeme:30'}, {'id' => 'changeme:22'}]
+        expect(mock_docs).to receive(:has_next?).and_return(false)
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
+          expect(page).to eq(1)
+          expect(rows).to eq(1000)
+          expect(method).to eq('select')
+          expect(hash[:params]).to be_a(Hash)
+          expect(hash[:params]).to include(:sort => [@sort_query])
+          expect(hash[:params]).to include(:fl   => 'id')
+          qs = hash[:params][:q].split(' AND ')
+          expect(qs).to include(@model_query, "foo:\"bar\"", "baz:\"quix\"", "baz:\"quack\"")
+        }.and_return('response' => {'docs' => mock_docs})
+        expect(SpecModel::Basic.find({:foo => 'bar', :baz => ['quix', 'quack']}, :sort => 'title_t desc')).to eq(['Fake Object1', 'Fake Object2'])
       end
 
     end
@@ -132,166 +123,146 @@ describe ActiveFedora::Base do
 
 
   describe '#find_each' do
-    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})
-      
-      SpecModel::Basic.should_receive(:find_one).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
-      SpecModel::Basic.should_receive(:find_one).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
+    it 'should query solr for all objects with :active_fedora_model_s of self.class' do
+      mock_docs = [{'id' => 'changeme:30'}, {'id' => 'changeme:22'}]
+      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).to receive(:find_one).with('changeme:30', nil).and_return(SpecModel::Basic.new(:pid => 'changeme:30'))
+      expect(SpecModel::Basic).to receive(:find_one).with('changeme:22', nil).and_return(SpecModel::Basic.new(:pid => 'changeme:22'))
+      yielded = double('yielded method')
+      expect(yielded).to receive(:run) { |obj| obj.class == SpecModel::Basic }.twice
       SpecModel::Basic.find_each(){|obj| yielded.run(obj) }
     end
-    describe "with conditions" do
-      it "should filter by the provided fields" do
-        SpecModel::Basic.should_receive(:find_one).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
-        SpecModel::Basic.should_receive(:find_one).with("changeme:22", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:22'))
+    describe 'with conditions' do
+      it 'should filter by the provided fields' do
+        expect(SpecModel::Basic).to receive(:find_one).with('changeme:30', nil).and_return(SpecModel::Basic.new(:pid => 'changeme:30'))
+        expect(SpecModel::Basic).to receive(:find_one).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|
-            page == 1 &&
-            rows == 1000 &&
-            method == 'select' &&
-            hash[:params] &&
-            hash[:params][:sort] == [@sort_query] && 
-            hash[:params][:fl] == 'id' && 
-            hash[:params][:q].split(" AND ").include?(@model_query) &&
-            hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
-            hash[:params][:q].split(" AND ").include?("baz:\"quix\"") &&
-            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
-        SpecModel::Basic.find_each({:foo=>'bar', :baz=>['quix','quack']}){|obj| yielded.run(obj) }
+        mock_docs = [{'id' => 'changeme:30'}, {'id' => 'changeme:22'}]
+        expect(mock_docs).to receive(:has_next?).and_return(false)
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
+          expect(page).to eq(1)
+          expect(rows).to eq(1000)
+          expect(method).to eq('select')
+          expect(hash[:params]).to be_a(Hash)
+          expect(hash[:params]).to include(:sort => [@sort_query])
+          expect(hash[:params]).to include(:fl   => 'id')
+          qs = hash[:params][:q].split(' AND ')
+          expect(qs).to include(@model_query, "foo:\"bar\"", "baz:\"quix\"", "baz:\"quack\"")
+        }.and_return('response' => {'docs' => mock_docs})
+        yielded = double('yielded method')
+        expect(yielded).to receive(:run) { |obj| obj.class == SpecModel::Basic }.twice
+        SpecModel::Basic.find_each({:foo => 'bar', :baz => ['quix', 'quack']}){|obj| yielded.run(obj) }
       end
     end
   end
 
   describe '#find_in_batches' do
-    describe "with conditions hash" do
-      it "should filter by the provided fields" 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|
-            page == 1 &&
-            rows == 1002 &&
-            method == 'select' &&
-            hash[:params] &&
-            hash[:params][:sort] == [@sort_query] && 
-            hash[:params][:fl] == 'id' && 
-            hash[:params][:q].split(" AND ").include?(@model_query) &&
-            hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
-            hash[:params][:q].split(" AND ").include?("baz:\"quix\"") &&
-            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(mock_docs).to receive(:has_next?).and_return(false)
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
+          expect(page).to eq(1)
+          expect(rows).to eq(1002)
+          expect(method).to eq('select')
+          expect(hash[:params]).to be_a(Hash)
+          expect(hash[:params]).to include(:sort => [@sort_query])
+          expect(hash[:params]).to include(:fl   => 'id')
+          qs = hash[:params][:q].split(' AND ')
+          expect(qs).to include(@model_query, "foo:\"bar\"", "baz:\"quix\"", "baz:\"quack\"")
+        }.and_return('response' => {'docs' => mock_docs})
+        yielded = double('yielded method')
+        expect(yielded).to receive(:run).with(mock_docs)
+        expect(SpecModel::Basic.find_in_batches({:foo => 'bar', :baz => ['quix', 'quack']}, {:batch_size => 1002, :fl => 'id'}){|group| yielded.run group }).not_to raise_error
       end
     end
   end
 
   describe '#count' 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
+    before :each do
+      @mock_result = {'response' => {'numFound' => 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
+    it 'should return a count' do
+      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 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 
+    it 'should allow conditions' do
+      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
+      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
 
-  describe '#last' do
-    describe 'with multiple objects' do
-      before(:all) do
-        (@a, @b, @c) = 3.times {SpecModel::Basic.create!}
-      end
-      it 'should return one object' do
-        SpecModel::Basic.class == SpecModel::Basic
-      end
-      it 'should return the last object sorted by pid' do
-        SpecModel::Basic.last == @c
-        SpecModel::Basic.last != @a 
-      end
-    end
-    describe 'with one object' do 
+  describe '#last and #last' do
+    describe 'with one object' do
       it 'should equal the first object when there is only one' do
+        SpecModel::Basic.delete_all
         a = SpecModel::Basic.create!
-        SpecModel::Basic.first == SpecModel::Basic.last
+        expect(SpecModel::Basic.first).to eq(SpecModel::Basic.last)
       end
     end
-  end
-
-  describe '#first' do
     describe 'with multiple objects' do
-      before(:all) do
-        (@a, @b, @c) = 3.times {SpecModel::Basic.create!}
-      end
-      it 'should return one object' do
-        SpecModel::Basic.class == SpecModel::Basic
-      end
-      it 'should return the last object sorted by pid' do
-        SpecModel::Basic.first == @a
-        SpecModel::Basic.first != @c 
+      before :each do
+        SpecModel::Basic.delete_all
+        @a = SpecModel::Basic.create!
+        @b = SpecModel::Basic.create!
+        @c = SpecModel::Basic.create!
       end
-    end
-    describe 'with one object' do 
-      it 'should equal the first object when there is only one' do
-        a = SpecModel::Basic.create!
-        SpecModel::Basic.first == SpecModel::Basic.last
+      it 'should return the first/last object sorted by pid' do
+        expect(SpecModel::Basic.last.class ).to eq(SpecModel::Basic)
+        expect(SpecModel::Basic.first.class).to eq(SpecModel::Basic)
+        expect(SpecModel::Basic.last).to eq(@c)
+        expect(SpecModel::Basic.last).not_to eq(@a)
+        expect(SpecModel::Basic.first).to eq(@a)
+        expect(SpecModel::Basic.first).not_to eq(@c)
       end
     end
   end
-  
+
   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|
-            q = args.first if args.is_a? Array
-            q ||= args
-            q.split(" AND ").include?(@model_query) &&
-            q.split(" AND ").include?("foo:\"bar\"") &&
-            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
+    before :each do
+      @mock_result = double('Result')
+    end
+
+    it 'should make a query to solr and return the results' do
+      expect(ActiveFedora::SolrService).to receive(:query) { |args|
+        q = args.first if args.is_a? Array
+        q ||= args
+        qs = q.split(' AND ')
+        qs.include?(@model_query) &&
+        qs.include?("foo:\"bar\"") &&
+        qs.include?("baz:\"quix\"") &&
+        qs.include?("baz:\"quack\"")
+      }.and_return(@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"')
-        }.and_return(mock_result)
-      SpecModel::Basic.find_with_conditions(:foo=>'9" Nails', :baz=>['7" version','quack']).should == mock_result
+    it 'should escape quotes' do
+      expect(ActiveFedora::SolrService).to receive(:query) { |args|
+        q = args.first if args.is_a? Array
+        q ||= args
+        qs = q.split(' AND ')
+        qs.include?(@model_query) &&
+        qs.include?(@model_query) &&
+        qs.include?('foo:"9\\" Nails"') &&
+        qs.include?('baz:"7\\" version"') &&
+        qs.include?('baz:"quack"')
+      }.and_return(@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
+    it "shouldn't use the class if it's called on AF:Base" do
+      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" 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
 end