active-fedora 6.8.0 → 7.0.0.pre1

data/spec/unit/persistence_spec.rb

@@ -1,28 +1,47 @@
 require 'spec_helper'
 
 describe ActiveFedora::Persistence do
-  before :all do
-    class SpecNode
-      include ActiveFedora::Persistence
+  context "internal methods" do
+    before :all do
+      class SpecNode
+        include ActiveFedora::Persistence
+      end
+    end
+    after :all do
+      Object.send(:remove_const, :SpecNode)
     end
-  end
-  after :all do
-    Object.send(:remove_const, :SpecNode)
-  end
 
-  subject { SpecNode.new }
+    subject { SpecNode.new }
 
-  describe '#create_needs_index?' do
-    it 'should be true' do
-      expect(subject.send(:create_needs_index?)).to be_truthy
+    describe "#create_needs_index?" do
+      it "should be true" do
+        subject.send(:create_needs_index?).should be_true
+      end
     end
-  end
 
-  describe '#update_needs_index?' do
-      it 'should be true' do
-        expect(subject.send(:update_needs_index?)).to be_truthy
+    describe "#update_needs_index?" do
+      it "should be true" do
+        subject.send(:update_needs_index?).should be_true
       end
+    end
   end
 
+  describe "an unsaved object" do
+    subject { ActiveFedora::Base.new }
+    it "should be deleteable (nop) and return the object" do
+      expect(subject.delete).to eq subject
+    end
+  end
 
+  describe "a saved object" do
+    subject { ActiveFedora::Base.create! }
+    describe "that is deleted" do
+      before do
+        subject.delete
+      end
+      it "should be frozen" do
+        expect(subject).to be_frozen
+      end
+    end
+  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
-      expect(ActiveFedora::Predicates.short_predicate('http://www.openarchives.org/OAI/2.0/itemID')).to eq(:oai_item_id)
+      ActiveFedora::Predicates.short_predicate('http://www.openarchives.org/OAI/2.0/itemID').should == :oai_item_id
     end
     it 'should parse uris' do
-      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')
+      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'
     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'}
         }
-      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)
+      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
     end
   end
-
+  
   it 'should provide .default_predicate_namespace' do
-    expect(ActiveFedora::Predicates.default_predicate_namespace).to eq('info:fedora/fedora-system:def/relations-external#')
+    ActiveFedora::Predicates.default_predicate_namespace.should == 'info:fedora/fedora-system:def/relations-external#'
   end
-
-  describe '#predicate_mappings' do
+ 
+  describe "#predicate_mappings" do 
 
     it 'should return a hash' do
-      expect(ActiveFedora::Predicates.predicate_mappings).to be_kind_of Hash
+      ActiveFedora::Predicates.predicate_mappings.should 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
-      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
+    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
     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|
-        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)
+      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
       end
     end
   end
 
   it 'should provide #predicate_lookup that maps symbols to common RELS-EXT predicates' do
-    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
+    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
   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
-      expect(ActiveFedora::Predicates.find_predicate(:is_part_of)).to eq(['isPartOf', 'info:fedora/fedora-system:def/relations-external#'])
+      ActiveFedora::Predicates.find_predicate(:is_part_of).should == ["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' }
         }
       }
-      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
+      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
     end
-
+    
     it 'should ensure that the configuration has the correct keys' do
-      expect { ActiveFedora::Predicates.predicate_config = { :foo => 'invalid!' } }.to raise_error TypeError
+      lambda { ActiveFedora::Predicates.predicate_config = { :foo => 'invalid!' } }.should 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
-      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#'])
+      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#"]
       # Pre-Existing predicates should be unharmed
-      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#'])
+      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#"]
     end
 
   end
-
+  
 end

data/spec/unit/property_spec.rb

@@ -4,22 +4,30 @@ 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
 
-  before :each do
-    mstub = double('model_stub')
-    @test_property = ActiveFedora::Property.new(mstub, 'file_name', :string)
+  it 'should provide .name' do
+    ActiveFedora::Property.should respond_to(:name)
   end
 
-  it 'should provide .new and .name' do
-    expect(ActiveFedora::Property).to respond_to(:new)
-    expect(ActiveFedora::Property).to respond_to(:name)
+  
+  it 'should provide .instance_variable_name' do
+    #ActiveFedora::Property.should respond_to(:instance_variable_name)
+    
+    @test_property.should respond_to(:instance_variable_name)
   end
 
   describe '.instance_variable_name' do
     it 'should return the value of the name attribute with an @ appended' do
-      expect(@test_property).to respond_to(:instance_variable_name)
-      expect(@test_property.instance_variable_name).to eql("@#{@test_property.name}")
+      @test_property.instance_variable_name.should 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
-    expect(@test_ds.ng_xml).to be_equivalent_to @sample_xml
+  it "from_xml should parse everything correctly" do
+    @test_ds.ng_xml.should be_equivalent_to @sample_xml
   end
 
-  it 'should create the right number of fields' do
-    expect(ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS.size).to eq(54)
+  it "should create the right number of fields" do
+    ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS.size.should == 54
   end
 
-  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)
+  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)
 
   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|
-      expect(s.has_key?(:multiple)).to eq(true)
+      s.has_key?(:multiple).should == true
     end
   end
-
+  
   after(:each) do
   end
-
+  
   describe '#new' do
     it 'should provide #new' do
-      expect(ActiveFedora::QualifiedDublinCoreDatastream).to respond_to(:new)
+      ActiveFedora::QualifiedDublinCoreDatastream.should 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
-          skip if el == :type
+          pending if el == :type
           value = "Hey #{el}"
-          @test_ds.send("#{el.to_s}=", value)
-          expect(@test_ds.send(el).first).to eq(value)  #Looking at first because creator has 2 nodes
+          @test_ds.send("#{el.to_s}=", value) 
+          @test_ds.send(el).first.should == 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.publisher = ['publisher1']
-      @test_ds.creator = ['creator1', 'creator2']
-      @test_ds.title = ['title1']
-
-      expect(@test_ds.to_xml).to be_equivalent_to('
+      @test_ds.to_xml.should 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
-      expect(solr[ActiveFedora::SolrService.solr_name('title', type: :string)]).to eq('War and Peace')
+      solr[ActiveFedora::SolrService.solr_name('title', type: :string)].should == "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
-      expect(test_ds.cust).to eq(['custom'])
+      test_ds.cust.should == ['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
-      expect(test_ds.dc_type).to eq(['sound'])
+      test_ds.field :dc_type, :string, path: "type", multiple: true
+      test_ds.dc_type.should == ['sound']
     end
   end
 

data/spec/unit/query_spec.rb

@@ -1,121 +1,123 @@
 require 'spec_helper'
 
-module SpecModel
-  class Basic < ActiveFedora::Base
-    def name
-      self.class
+describe ActiveFedora::Base do
+  
+  before(:all) do
+    module SpecModel
+      class Basic < ActiveFedora::Base
+      end
     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
-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'
+  
+  after(:all) do
+    Object.send(:remove_const, :SpecModel)
   end
 
-  describe '#find_one' do
-    describe 'when called on AF::Base' do
-      it 'should notify of deprecation if no cast parameter is passed' do
-        expect(Deprecation).to receive(:warn).at_least(1).times
-        expect { ActiveFedora::Base.find_one('mypid:99999') }.to raise_error(ActiveFedora::ObjectNotFoundError)
+  describe ":all" do
+    before { ActiveFedora::Base.stub(: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")
+        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"]
       end
     end
-    describe 'when called on a model extending AF::Base' do
-      it 'should not have a deprecation warning when no cast parameter is passed' do
-        expect(Deprecation).not_to receive(:warn)
-        expect { SpecModel::Basic.find_one('mypid:99999') }.to raise_error(ActiveFedora::ObjectNotFoundError)
+    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")
+        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"]
       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
-            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
-            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
+    describe "with :cast false" do
+      describe "and a pid is specified" do
+        it "should use SpecModel::Basic.allocate.init_with to instantiate an object" do
+          SpecModel::Basic.any_instance.should_receive(:init_with).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
         end
-      end
-      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)
-          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
-          allow_any_instance_of(Rubydora::Fc3Service).to receive(:object).and_raise(RestClient::ResourceNotFound)
-          expect(SpecModel::Basic).to receive(:connection_for_pid).with('_PID_')
-          expect {SpecModel::Basic.find('_PID_')}.to raise_error ActiveFedora::ObjectNotFoundError
+        it "should raise an exception if it is not found" do
+          Rubydora::Fc3Service.any_instance.should_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
         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 ))
-        expect(ActiveFedora::DigitalObject).to receive(:find).and_return(double('inner obj', :'new?' => false))
-        SpecModel::Basic.find('_PID_', :cast => true)
+    describe "with default :cast of true" do
+      it "should use SpecModel::Basic.allocate.init_with to instantiate an object" do
+        SpecModel::Basic.any_instance.should_receive(:init_with).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_")
       end
     end
 
-    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')
+    describe "with conditions" do
+      before do
+        ActiveFedora::Base.stub(:relation => relation)
+        relation.stub(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")
+
+        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"]
+      end
 
-        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'])
+      it "should correctly query for empty strings" do
+        SpecModel::Basic.find( :active_fedora_model_ssi => '').count.should == 0
       end
 
-      it 'should correctly query for empty strings' do
-        expect(SpecModel::Basic.find(:active_fedora_model_ssi => '').count).to eq(0)
+      it 'should correctly query for empty arrays' do
+        SpecModel::Basic.find( :active_fedora_model_ssi => []).count.should == 0
       end
 
-      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')
+      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")
 
-        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'])
+        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"]
       end
 
     end
@@ -123,146 +125,168 @@ 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'}]
-      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
+    before { ActiveFedora::Base.stub(: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})
+      
+      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'))
+      yielded = double("yielded method")
+      yielded.should_receive(:run).with { |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
-        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'))
+    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'))
 
-        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) }
+        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) }
       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')
-        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
+        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
       end
     end
   end
 
   describe '#count' do
-    before :each do
-      @mock_result = {'response' => {'numFound' => 7}}
+    
+    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
     end
-    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)
+    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
     end
-    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)
+
+    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 
     end
   end
 
-  describe '#last and #last' do
-    describe 'with one object' do
+  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 
       it 'should equal the first object when there is only one' do
-        SpecModel::Basic.delete_all
         a = SpecModel::Basic.create!
-        expect(SpecModel::Basic.first).to eq(SpecModel::Basic.last)
+        SpecModel::Basic.first == SpecModel::Basic.last
       end
     end
+  end
+
+  describe '#first' do
     describe 'with multiple objects' do
-      before :each do
-        SpecModel::Basic.delete_all
-        @a = SpecModel::Basic.create!
-        @b = SpecModel::Basic.create!
-        @c = SpecModel::Basic.create!
+      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 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)
+      it 'should return the last object sorted by pid' do
+        SpecModel::Basic.first == @a
+        SpecModel::Basic.first != @c 
+      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
       end
     end
   end
-
+  
   describe '#find_with_conditions' do
-    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)
+    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
     end
 
-    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)
+    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
     end
 
-    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)
+    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
     end
     it "should use the query string if it's provided" do
-      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)
+      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
     end
   end
 end